rustc_parse_format: improve diagnostics for unsupported debug = syntax

Detect Python-style f-string debug syntax in format strings and emit a
clear diagnostic explaining that it is not supported in Rust. When the
intended operation can be inferred, suggest the corresponding Rust
alternative (e.g. `dbg!` for `{x=}`).

This is a part of an effort toward #145718

Signed-off-by: Usman Akinyemi <usmanakinyemi202@gmail.com>

Author: Unique-Usman

compiler/rustc_builtin_macros/messages.ftl

@@ -316,3 +316,5 @@ builtin_macros_unexpected_lit = expected path to a trait, found literal
     .other = for example, write `#[derive(Debug)]` for `Debug`
 
 builtin_macros_unnameable_test_items = cannot test inner items
+
+builtin_macros_use_rust_debug_printing_macro = use rust debug printing macro

compiler/rustc_builtin_macros/src/errors.rs

@@ -652,6 +652,19 @@ pub(crate) enum InvalidFormatStringSuggestion {
         #[primary_span]
         span: Span,
     },
+
+    #[multipart_suggestion(
+        builtin_macros_use_rust_debug_printing_macro,
+        style = "verbose",
+        applicability = "machine-applicable"
+    )]
+    UseRustDebugPrintingMacro {
+        #[suggestion_part(code = "dbg!(")]
+        macro_span: Span,
+        #[suggestion_part(code = "{{{ident}}}")]
+        fmt_span: Span,
+        ident: String,
+    },
 }
 
 #[derive(Diagnostic)]

compiler/rustc_builtin_macros/src/format.rs

@@ -333,6 +333,19 @@ fn make_format_args(
                 let span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
                 e.sugg_ = Some(errors::InvalidFormatStringSuggestion::AddMissingColon { span });
             }
+            parse::Suggestion::UseRustDebugPrintingMacro(span) => {
+                let fmt_span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
+
+                // Span of `format!` or `println!`
+                // let ident =
+                // let macro_span =
+
+                e.sugg_ = Some(errors::InvalidFormatStringSuggestion::UseRustDebugPrintingMacro {
+                    macro_span,
+                    fmt_span,
+                    ident,
+                });
+            }
         }
         let guar = ecx.dcx().emit_err(e);
         return ExpandResult::Ready(Err(guar));

compiler/rustc_parse_format/src/lib.rs

@@ -187,6 +187,9 @@ pub enum Suggestion {
     /// Add missing colon:
     /// `format!("{foo?}")` -> `format!("{foo:?}")`
     AddMissingColon(Range<usize>),
+    /// Use Rust format string:
+    /// `format!("{x=}")` -> `dbg!("{x}")`
+    UseRustDebugPrintingMacro(Range<usize>),
 }
 
 /// The parser structure for interpreting the input format string. This is
@@ -461,6 +464,7 @@ impl<'input> Parser<'input> {
                 ('?', '}') => self.missing_colon_before_debug_formatter(),
                 ('?', _) => self.suggest_format_debug(),
                 ('<' | '^' | '>', _) => self.suggest_format_align(c),
+                ('=', _) => self.suggest_rust_debug_printing_macro(),
                 _ => self.suggest_positional_arg_instead_of_captured_arg(arg),
             }
         }
@@ -870,6 +874,25 @@ impl<'input> Parser<'input> {
         }
     }
 
+    fn suggest_rust_debug_printing_macro(&mut self) {
+        if let Some((range, _)) = self.consume_pos('=') {
+            let span = range.clone();
+            self.errors.insert(
+                0,
+                ParseError {
+                    description: "expected `}`, found `=`".to_owned(),
+                    note: Some(format!("to print `{{`, you can escape it using `{{{{`",)),
+                    label:
+                        "python f-string debug `=` is not supported in rust, use `dbg(x)` instead"
+                            .to_owned(),
+                    span: range,
+                    secondary_label: None,
+                    suggestion: Suggestion::UseRustDebugPrintingMacro(span),
+                },
+            );
+        }
+    }
+
     fn suggest_format_align(&mut self, alignment: char) {
         if let Some((range, _)) = self.consume_pos(alignment) {
             self.errors.insert(

tests/ui/fmt/format-string-error-2.rs

@@ -86,4 +86,7 @@ raw  { \n
 
     println!("{x?}, world!",);
     //~^ ERROR invalid format string: expected `}`, found `?`
+
+    println!("{x=}, world!",);
+    //~^ ERROR invalid format string: expected `}`, found `=`
 }

tests/ui/fmt/format-string-error-2.stderr

@@ -188,5 +188,13 @@ LL |     println!("{x?}, world!",);
    |
    = note: to print `{`, you can escape it using `{{`
 
-error: aborting due to 19 previous errors
+error: invalid format string: expected `}`, found `=`
+  --> $DIR/format-string-error-2.rs:90:17
+   |
+LL |     println!("{x=}, world!",);
+   |                 ^ python f-string debug `=` is not supported in rust, use `dbg(x)` instead in format string
+   |
+   = note: to print `{`, you can escape it using `{{`
+
+error: aborting due to 20 previous errors