Rollup merge of #158256 - Mark-Simulacrum:no-panic-pm-parsing, r=bjorn3

Avoid parser panics bubbling out to proc macros

Currently, rustc can emit a FatalError diagnostic during parsing of literals and tokenstreams. These are handled under the hood as a panic, which means that proc-macro code needed to catch_unwind if it wanted to fallibly parse some code. These still emit diagnostics, so in practice this isn't a full fix, but it at least makes the interface on the macro side a bit more uniform. The long-term fix should be to get rid of those FatalErrors (and in general all diagnostics that actually get emitted out during parsing, not just returned), but this seems like a reasonable improvement in the meantime.

This is primarily motivated by wasm proc macros which can't use catch_unwind and so this lets the test's output be the same with and without them.

r? bjorn3

Author: JonathanBrouwer

compiler/rustc_expand/src/proc_macro_server.rs

@@ -490,9 +490,11 @@ impl server::Server for Rustc<'_, '_> {
     fn literal_from_str(&mut self, s: &str) -> Result<Literal<Self::Span, Self::Symbol>, String> {
         let name = FileName::proc_macro_source_code(s);
 
-        let mut parser =
+        let mut parser = rustc_errors::catch_fatal_errors(|| {
             new_parser_from_source_str(self.psess(), name, s.to_owned(), StripTokens::Nothing)
-                .map_err(cancel_diags_into_string)?;
+        })
+        .map_err(|_| String::from("failed to parse to literal"))?
+        .map_err(cancel_diags_into_string)?;
 
         let first_span = parser.token.span.data();
         let minus_present = parser.eat(exp!(Minus));
@@ -569,12 +571,15 @@ impl server::Server for Rustc<'_, '_> {
     }
 
     fn ts_from_str(&mut self, src: &str) -> Result<Self::TokenStream, String> {
-        source_str_to_stream(
-            self.psess(),
-            FileName::proc_macro_source_code(src),
-            src.to_string(),
-            Some(self.call_site),
-        )
+        rustc_errors::catch_fatal_errors(|| {
+            source_str_to_stream(
+                self.psess(),
+                FileName::proc_macro_source_code(src),
+                src.to_string(),
+                Some(self.call_site),
+            )
+        })
+        .map_err(|_| String::from("failed to parse to tokenstream"))?
         .map_err(cancel_diags_into_string)
     }
 

tests/ui/proc-macro/auxiliary/nonfatal-parsing-body.rs

@@ -7,12 +7,14 @@ use proc_macro::*;
 use self::Mode::*;
 
 // FIXME: all cases should become `NormalOk` or `NormalErr`
+//
+// And .stderr should be empty (no diagnostics should get emitted from fallible parsing in the proc
+// macro).
 #[derive(PartialEq, Clone, Copy)]
 enum Mode {
     NormalOk,
     NormalErr,
     OtherError,
-    OtherWithPanic,
 }
 
 fn print_unspanned<T>(s: &str) -> Result<T, LexError>
@@ -43,12 +45,11 @@ where
             assert!(t.is_err());
         }
         OtherError => {
-            print_unspanned::<T>(s);
-        }
-        OtherWithPanic => {
-            if catch_unwind(|| print_unspanned::<T>(s)).is_ok() {
-                eprintln!("{s} did not panic");
-            }
+            let t = print_unspanned::<T>(s);
+            // For now we assert OK here, but in the future this should all move to NormalErr.
+            // Any case that's failing this should go to NormalErr, probably after verifying that a
+            // diagnostic did get emitted.
+            assert!(t.is_ok());
         }
     }
 }
@@ -136,18 +137,18 @@ pub fn run() {
     // FIXME: all of the cases below should return an Err and emit no diagnostics, but don't yet.
 
     // emits diagnostics and returns LexError
-    lit("r'r'", OtherError);
-    lit("c'r'", OtherError);
-    lit("\u{2000}", OtherError);
+    lit("r'r'", NormalErr);
+    lit("c'r'", NormalErr);
+    lit("\u{2000}", NormalErr);
 
     // emits diagnostic and returns a seemingly valid tokenstream
     stream("r'r'", OtherError);
     stream("c'r'", OtherError);
     stream("\u{2000}", OtherError);
 
     for parse in [stream as fn(&str, Mode), lit] {
-        // emits diagnostic(s), then panics
-        parse("r#", OtherWithPanic);
+        // emits diagnostic(s), then returns LexError
+        parse("r#", NormalErr);
 
         // emits diagnostic(s), then returns Ok(Literal { kind: ErrWithGuar, .. })
         parse("0b2", OtherError);
@@ -158,9 +159,10 @@ pub fn run() {
             "'
 '", OtherError,
         );
-        parse(&format!("r{0}\"a\"{0}", "#".repeat(256)), OtherWithPanic);
-
-        // emits diagnostic, then, when parsing as a lit, returns LexError, otherwise ErrWithGuar
-        parse("/*a*/ 0b2 //", OtherError);
+        parse(&format!("r{0}\"a\"{0}", "#".repeat(256)), NormalErr);
     }
+
+    // emits diagnostic, then, when parsing as a lit, returns LexError, otherwise ErrWithGuar
+    lit("/*a*/ 0b2 //", NormalErr);
+    stream("/*a*/ 0b2 //", OtherError);
 }

tests/ui/proc-macro/nonfatal-parsing.stderr

@@ -130,15 +130,6 @@ LL |     nonfatal_parsing::run!();
    |
    = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: invalid digit for a base 2 literal
-  --> $DIR/nonfatal-parsing.rs:15:5
-   |
-LL |     nonfatal_parsing::run!();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-   = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error: found invalid character; only `#` is allowed in raw string delimitation: \u{0}
   --> <proc-macro source code>:1:1
    |
@@ -199,6 +190,15 @@ error: invalid digit for a base 2 literal
 LL | /*a*/ 0b2 //
    |         ^
 
+error: invalid digit for a base 2 literal
+  --> $DIR/nonfatal-parsing.rs:15:5
+   |
+LL |     nonfatal_parsing::run!();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+   = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error: aborting due to 22 previous errors
 
 For more information about this error, try `rustc --explain E0768`.

tests/ui/proc-macro/nonfatal-parsing.stdout

@@ -52,15 +52,19 @@ Err(LexError("not a literal"))
 Ok(TokenStream [Ident { ident: "r", span: Span }, Literal { kind: Char, symbol: "r", suffix: None, span: Span }])
 Ok(TokenStream [Ident { ident: "c", span: Span }, Literal { kind: Char, symbol: "r", suffix: None, span: Span }])
 Ok(TokenStream [])
+Err(LexError("failed to parse to tokenstream"))
 Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "0b2", suffix: None, span: Span }])
 Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "0b", suffix: Some("f32"), span: Span }])
 Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "0b0.0", suffix: Some("f32"), span: Span }])
 Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "'''", suffix: None, span: Span }])
 Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "'\n'", suffix: None, span: Span }])
-Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "0b2", suffix: None, span: Span }])
+Err(LexError("failed to parse to tokenstream"))
+Err(LexError("failed to parse to literal"))
 Ok(Literal { kind: ErrWithGuar, symbol: "0b2", suffix: None, span: Span })
 Ok(Literal { kind: ErrWithGuar, symbol: "0b", suffix: Some("f32"), span: Span })
 Ok(Literal { kind: ErrWithGuar, symbol: "0b0.0", suffix: Some("f32"), span: Span })
 Ok(Literal { kind: ErrWithGuar, symbol: "'''", suffix: None, span: Span })
 Ok(Literal { kind: ErrWithGuar, symbol: "'\n'", suffix: None, span: Span })
+Err(LexError("failed to parse to literal"))
 Err(LexError("comment or whitespace around literal"))
+Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "0b2", suffix: None, span: Span }])