wip

Author: nyurik

clippy_lints/src/format_args.rs

@@ -145,28 +145,8 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
                     check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg.param.value);
                     check_to_string_in_format_args(cx, name, arg.param.value);
                 }
-
-                if !meets_msrv(self.msrv, msrvs::FORMAT_ARGS_CAPTURE) {
-                    return;
-                }
-                let mut inline_spans = Vec::new();
-                // If any of the arguments are referenced by an index number,
-                // and that argument is not a simple variable and cannot be inlined,
-                // we cannot remove any other arguments in the format string,
-                // because the index numbers might be wrong after inlining.
-                // Example of an un-inlinable format:  print!("{}{1}", foo, 2)
-                let do_inlining = format_args.params().all(|p| check_inline(cx, &p, &mut inline_spans));
-                if do_inlining && !inline_spans.is_empty()
-                {
-                    span_lint_and_then(
-                        cx,
-                        UNINLINED_FORMAT_ARGS,
-                        outermost_expn_data.call_site,
-                        "variables can be used directly in the `format!` string",
-                        |diag| {
-                            diag.multipart_suggestion("change this to", inline_spans, Applicability::MachineApplicable);
-                        },
-                    );
+                if meets_msrv(self.msrv, msrvs::FORMAT_ARGS_CAPTURE) {
+                    check_uninlined_args(cx, &format_args, outermost_expn_data.call_site);
                 }
             }
         }
@@ -175,7 +155,53 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_inline(cx: &LateContext<'_>, param: &FormatParam<'_>, inline_spans: &mut Vec<(Span, String)>) -> bool {
+fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_site: Span) {
+    let mut fixes = Vec::new();
+    // If any of the arguments are referenced by an index number,
+    // and that argument is not a simple variable and cannot be inlined,
+    // we cannot remove any other arguments in the format string,
+    // because the index numbers might be wrong after inlining.
+    // Example of an un-inlinable format:  print!("{}{1}", foo, 2)
+    if !args.params().all(|p| check_one_arg(cx, &p, &mut fixes)) || fixes.is_empty() {
+        return;
+    }
+
+    // Handle a very rare case: `format!(indoc!("{}"), foo)` must not be inlined.
+    // If inlined, it will cause a compilation error:
+    //     > to avoid ambiguity, `format_args!` cannot capture variables
+    //     > when the format string is expanded from a macro
+    // @Alexendoo explanation:
+    //     > indoc! is a proc macro that is producing a string literal with its span
+    //     > set to its input it's not marked as from expansion, and since it's compatible
+    //     > tokenization wise clippy_utils::is_from_proc_macro wouldn't catch it either
+    // Hacky solution (TBD if it should be improved):
+    //     iterate over all tokens between the format string and the first argument,
+    //     and ensure we do not see any closing brackets/braces/parens.
+    // This might be a relatively expensive test, so do it only we are ready to replace.
+
+    /*
+        let fmt_str_span = args.format_string.span;
+        println!("1st: {}", snippet_opt(cx, fmt_str_span).unwrap());
+        let first_arg_span = walk_chain(fmt_str_span, fmt_str_span.ctxt());
+        println!("2nd: {}", snippet_opt(cx, first_arg_span).unwrap());
+        let between = fmt_str_span.with_lo(fmt_str_span.hi()).with_hi(first_arg_span.lo());
+        println!("3rd: {}", snippet_opt(cx, between).unwrap());
+        if let Some(between_snippet) = snippet_opt(cx, between) {
+            if !tokenize(&between_snippet).any(|t| matches!(t.kind, CloseParen | CloseBrace | CloseBracket))
+    */
+
+    span_lint_and_then(
+        cx,
+        UNINLINED_FORMAT_ARGS,
+        call_site,
+        "variables can be used directly in the `format!` string",
+        |diag| {
+            diag.multipart_suggestion("change this to", fixes, Applicability::MachineApplicable);
+        },
+    );
+}
+
+fn check_one_arg(cx: &LateContext<'_>, param: &FormatParam<'_>, fixes: &mut Vec<(Span, String)>) -> bool {
     if matches!(param.kind, Implicit | Starred | Named(_) | Numbered)
         && let ExprKind::Path(QPath::Resolved(None, path)) = param.value.kind
         && let Path { span, segments, .. } = path
@@ -186,9 +212,9 @@ fn check_inline(cx: &LateContext<'_>, param: &FormatParam<'_>, inline_spans: &mu
             FormatParamUsage::Width => format!("{}$", segment.ident.name),
             FormatParamUsage::Precision => format!(".{}$", segment.ident.name),
         };
-        inline_spans.push((param.span, replacement));
+        fixes.push((param.span, replacement));
         let arg_span = expand_past_previous_comma(cx, *span);
-        inline_spans.push((arg_span, String::new()));
+        fixes.push((arg_span, String::new()));
         true  // successful inlining, continue checking
     } else {
         // if we can't inline a numbered argument, we can't continue