Rollup merge of rust-lang#157079 - qaijuang:raw-expr-list-recovery, r=Kivooeo

Don't recover `&raw EXPR` as a missing comma

The parser already has a targeted suggestion for `&raw EXPR`, added in rust-lang#139392, telling the user that `&raw` must be followed by `const` or `mut`.

In comma-separated expression lists, the generic missing-comma recovery would then treat the expression after `raw` as the next list element. That produced follow-up diagnostics like:

- `help: missing ','`
- `cannot find value raw in this scope`
- an arity error for calls such as `takes_raw_ptr(&raw x)`

This PR avoids that comma recovery when we are already in the `&raw` missing-`const`/`mut` diagnostic path. For function calls, it preserves the call expression with a single error argument, so useful later diagnostics such as `cannot find function f` are still emitted.

Fixes rust-lang#157015.

Author: JonathanBrouwer

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -752,16 +752,19 @@ impl<'a> Parser<'a> {
         Err(err)
     }
 
+    pub(super) fn is_expected_raw_ref_mut(&self) -> bool {
+        self.prev_token.is_keyword(kw::Raw)
+            && self.expected_token_types.contains(TokenType::KwMut)
+            && self.expected_token_types.contains(TokenType::KwConst)
+            && self.token.can_begin_expr()
+    }
+
     /// Adds a label when `&raw EXPR` was written instead of `&raw const EXPR`/`&raw mut EXPR`.
     ///
     /// Given that not all parser diagnostics flow through `expected_one_of_not_found`, this
     /// label may need added to other diagnostics emission paths as needed.
     pub(super) fn label_expected_raw_ref(&mut self, err: &mut Diag<'_>) {
-        if self.prev_token.is_keyword(kw::Raw)
-            && self.expected_token_types.contains(TokenType::KwMut)
-            && self.expected_token_types.contains(TokenType::KwConst)
-            && self.token.can_begin_expr()
-        {
+        if self.is_expected_raw_ref_mut() {
             err.span_suggestions(
                 self.prev_token.span.shrink_to_hi(),
                 "`&raw` must be followed by `const` or `mut` to be a raw reference expression",

compiler/rustc_parse/src/parser/expr.rs

@@ -1279,15 +1279,38 @@ impl<'a> Parser<'a> {
         };
         let open_paren = self.token.span;
 
-        let seq = self
-            .parse_expr_paren_seq()
-            .map(|args| self.mk_expr(lo.to(self.prev_token.span), self.mk_call(fun, args)));
+        let seq = match self.parse_expr_paren_seq() {
+            Ok(args) => Ok(self.mk_expr(lo.to(self.prev_token.span), self.mk_call(fun, args))),
+            Err(err) if self.is_expected_raw_ref_mut() => {
+                let guar = err.emit();
+                // Preserve the call expression so later passes can still diagnose the callee,
+                // while treating the malformed `&raw <expr>` argument as an error expression.
+                let args = self.recover_raw_ref_call_args(guar);
+                return self.mk_expr(lo.to(self.prev_token.span), self.mk_call(fun, args));
+            }
+            Err(err) => Err(err),
+        };
         match self.maybe_recover_struct_lit_bad_delims(lo, open_paren, seq, snapshot) {
             Ok(expr) => expr,
             Err(err) => self.recover_seq_parse_error(exp!(OpenParen), exp!(CloseParen), lo, err),
         }
     }
 
+    fn recover_raw_ref_call_args(&mut self, guar: ErrorGuaranteed) -> ThinVec<Box<Expr>> {
+        let err_span = self.prev_token.span.to(self.token.span);
+        let mut args = thin_vec![self.mk_expr_err(err_span, guar)];
+        while self.token != token::Eof && self.token != token::CloseParen {
+            if self.eat(exp!(Comma)) && self.token != token::Eof && self.token != token::CloseParen
+            {
+                args.push(self.mk_expr_err(self.prev_token.span.shrink_to_hi(), guar));
+            } else {
+                self.parse_token_tree();
+            }
+        }
+        let _ = self.eat(exp!(CloseParen));
+        args
+    }
+
     /// If we encounter a parser state that looks like the user has written a `struct` literal with
     /// parentheses instead of braces, recover the parser state and provide suggestions.
     #[instrument(skip(self, seq, snapshot), level = "trace")]

compiler/rustc_parse/src/parser/mod.rs

@@ -917,6 +917,13 @@ impl<'a> Parser<'a> {
                             }
 
                             // Attempt to keep parsing if it was an omitted separator.
+                            // `&raw <expr>` already has a specific suggestion for missing
+                            // `const`/`mut`, so don't recover `<expr>` as the next element in
+                            // a comma-separated list.
+                            if exp.token_type == TokenType::Comma && self.is_expected_raw_ref_mut()
+                            {
+                                return Err(expect_err);
+                            }
                             self.last_unexpected_token_span = None;
                             match f(self) {
                                 Ok(t) => {

tests/ui/parser/recover/raw-no-const-mut-arg-list.rs

@@ -0,0 +1,12 @@
+// Regression test for https://github.com/rust-lang/rust/issues/157015.
+
+fn takes_raw_ptr(_: *const u32) {}
+fn takes_raw_ptr_args(_: *const u32, _: *const u32) {}
+
+fn main() {
+    let x = 0u32;
+    takes_raw_ptr(&raw x);
+    //~^ ERROR expected one of
+    takes_raw_ptr_args(&raw x, &raw x);
+    //~^ ERROR expected one of
+}

tests/ui/parser/recover/raw-no-const-mut-arg-list.stderr

@@ -0,0 +1,28 @@
+error: expected one of `!`, `)`, `,`, `.`, `::`, `?`, `const`, `mut`, `{`, or an operator, found `x`
+  --> $DIR/raw-no-const-mut-arg-list.rs:8:24
+   |
+LL |     takes_raw_ptr(&raw x);
+   |                        ^ expected one of 10 possible tokens
+   |
+help: `&raw` must be followed by `const` or `mut` to be a raw reference expression
+   |
+LL |     takes_raw_ptr(&raw const x);
+   |                        +++++
+LL |     takes_raw_ptr(&raw mut x);
+   |                        +++
+
+error: expected one of `!`, `)`, `,`, `.`, `::`, `?`, `const`, `mut`, `{`, or an operator, found `x`
+  --> $DIR/raw-no-const-mut-arg-list.rs:10:29
+   |
+LL |     takes_raw_ptr_args(&raw x, &raw x);
+   |                             ^ expected one of 10 possible tokens
+   |
+help: `&raw` must be followed by `const` or `mut` to be a raw reference expression
+   |
+LL |     takes_raw_ptr_args(&raw const x, &raw x);
+   |                             +++++
+LL |     takes_raw_ptr_args(&raw mut x, &raw x);
+   |                             +++
+
+error: aborting due to 2 previous errors
+

tests/ui/parser/recover/raw-no-const-mut.rs

@@ -6,8 +6,6 @@ fn a() {
 fn b() {
     [&raw const 1, &raw 2]
     //~^ ERROR expected one of
-    //~| ERROR cannot find value `raw` in this scope
-    //~| ERROR cannot take address of a temporary
 }
 
 fn c() {
@@ -18,7 +16,6 @@ fn c() {
 fn d() {
     f(&raw 2);
     //~^ ERROR expected one of
-    //~| ERROR cannot find value `raw` in this scope
     //~| ERROR cannot find function `f` in this scope
 }
 

tests/ui/parser/recover/raw-no-const-mut.stderr

@@ -23,19 +23,15 @@ LL |     [&raw const 1, &raw const 2]
    |                         +++++
 LL |     [&raw const 1, &raw mut 2]
    |                         +++
-help: missing `,`
-   |
-LL |     [&raw const 1, &raw, 2]
-   |                        +
 
 error: expected `{`, found `z`
-  --> $DIR/raw-no-const-mut.rs:14:18
+  --> $DIR/raw-no-const-mut.rs:12:18
    |
 LL |     if x == &raw z {}
    |                  ^ expected `{`
    |
 note: the `if` expression is missing a block after this condition
-  --> $DIR/raw-no-const-mut.rs:14:8
+  --> $DIR/raw-no-const-mut.rs:12:8
    |
 LL |     if x == &raw z {}
    |        ^^^^^^^^^
@@ -47,7 +43,7 @@ LL |     if x == &raw mut z {}
    |                  +++
 
 error: expected one of `!`, `)`, `,`, `.`, `::`, `?`, `const`, `mut`, `{`, or an operator, found `2`
-  --> $DIR/raw-no-const-mut.rs:19:12
+  --> $DIR/raw-no-const-mut.rs:17:12
    |
 LL |     f(&raw 2);
    |            ^ expected one of 10 possible tokens
@@ -58,13 +54,9 @@ LL |     f(&raw const 2);
    |            +++++
 LL |     f(&raw mut 2);
    |            +++
-help: missing `,`
-   |
-LL |     f(&raw, 2);
-   |           +
 
 error: expected one of `!`, `.`, `::`, `;`, `?`, `const`, `mut`, `{`, `}`, or an operator, found `1`
-  --> $DIR/raw-no-const-mut.rs:27:14
+  --> $DIR/raw-no-const-mut.rs:24:14
    |
 LL |     x = &raw 1;
    |              ^ expected one of 10 possible tokens
@@ -76,26 +68,8 @@ LL |     x = &raw const 1;
 LL |     x = &raw mut 1;
    |              +++
 
-error[E0425]: cannot find value `raw` in this scope
-  --> $DIR/raw-no-const-mut.rs:7:21
-   |
-LL |     [&raw const 1, &raw 2]
-   |                     ^^^ not found in this scope
-
-error[E0425]: cannot find value `raw` in this scope
-  --> $DIR/raw-no-const-mut.rs:19:8
-   |
-LL |     f(&raw 2);
-   |        ^^^ not found in this scope
-
-error[E0745]: cannot take address of a temporary
-  --> $DIR/raw-no-const-mut.rs:7:17
-   |
-LL |     [&raw const 1, &raw 2]
-   |                 ^ temporary value
-
 error[E0425]: cannot find function `f` in this scope
-  --> $DIR/raw-no-const-mut.rs:19:5
+  --> $DIR/raw-no-const-mut.rs:17:5
    |
 LL | fn a() {
    | ------ similarly named function `a` defined here
@@ -109,7 +83,6 @@ LL -     f(&raw 2);
 LL +     a(&raw 2);
    |
 
-error: aborting due to 9 previous errors
+error: aborting due to 6 previous errors
 
-Some errors have detailed explanations: E0425, E0745.
-For more information about an error, try `rustc --explain E0425`.
+For more information about this error, try `rustc --explain E0425`.