Auto merge of rust-lang#126571 - nnethercote:less-maybe_whole-expr-2,…

… r=<try>

Less `maybe_whole_expr`, take 2

I first tried this in rust-lang#107550. I now think it's worth doing again, as a precursor to #1241414.

r? `@petrochenkov`

compiler/rustc_ast_lowering/messages.ftl

@@ -3,10 +3,6 @@ ast_lowering_abi_specified_multiple_times =
     .label = previously specified here
     .note = these ABIs are equivalent on the current target
 
-ast_lowering_arbitrary_expression_in_pattern =
-    arbitrary expressions aren't allowed in patterns
-    .pattern_from_macro_note = the `expr` fragment specifier forces the metavariable's content to be an expression
-
 ast_lowering_argument = argument
 
 ast_lowering_assoc_ty_binding_in_dyn =

compiler/rustc_ast_lowering/src/errors.rs

@@ -363,15 +363,6 @@ pub struct NeverPatternWithGuard {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(ast_lowering_arbitrary_expression_in_pattern)]
-pub struct ArbitraryExpressionInPattern {
-    #[primary_span]
-    pub span: Span,
-    #[note(ast_lowering_pattern_from_macro_note)]
-    pub pattern_from_macro_note: bool,
-}
-
 #[derive(Diagnostic)]
 #[diag(ast_lowering_inclusive_range_with_no_end)]
 pub struct InclusiveRangeWithNoEnd {

compiler/rustc_ast_lowering/src/pat.rs

@@ -1,6 +1,4 @@
-use super::errors::{
-    ArbitraryExpressionInPattern, ExtraDoubleDot, MisplacedDoubleDot, SubTupleBinding,
-};
+use super::errors::{ExtraDoubleDot, MisplacedDoubleDot, SubTupleBinding};
 use super::ResolverAstLoweringExt;
 use super::{ImplTraitContext, LoweringContext, ParamMode};
 use crate::ImplTraitPosition;
@@ -338,14 +336,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             | ExprKind::Dummy => {}
             ExprKind::Path(..) if allow_paths => {}
             ExprKind::Unary(UnOp::Neg, inner) if matches!(inner.kind, ExprKind::Lit(_)) => {}
-            _ => {
-                let pattern_from_macro = expr.is_approximately_pattern();
-                let guar = self.dcx().emit_err(ArbitraryExpressionInPattern {
-                    span: expr.span,
-                    pattern_from_macro_note: pattern_from_macro,
-                });
-                return self.arena.alloc(self.expr_err(expr.span, guar));
-            }
+            kind => panic!("unexpected expr kind {kind:?}"),
         }
         self.lower_expr(expr)
     }

compiler/rustc_parse/src/parser/expr.rs

@@ -38,36 +38,6 @@ use rustc_span::{BytePos, ErrorGuaranteed, Pos, Span};
 use thin_vec::{thin_vec, ThinVec};
 use tracing::instrument;
 
-/// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression
-/// dropped into the token stream, which happens while parsing the result of
-/// macro expansion). Placement of these is not as complex as I feared it would
-/// be. The important thing is to make sure that lookahead doesn't balk at
-/// `token::Interpolated` tokens.
-macro_rules! maybe_whole_expr {
-    ($p:expr) => {
-        if let token::Interpolated(nt) = &$p.token.kind {
-            match &**nt {
-                token::NtExpr(e) | token::NtLiteral(e) => {
-                    let e = e.clone();
-                    $p.bump();
-                    return Ok(e);
-                }
-                token::NtPath(path) => {
-                    let path = (**path).clone();
-                    $p.bump();
-                    return Ok($p.mk_expr($p.prev_token.span, ExprKind::Path(None, path)));
-                }
-                token::NtBlock(block) => {
-                    let block = block.clone();
-                    $p.bump();
-                    return Ok($p.mk_expr($p.prev_token.span, ExprKind::Block(block, None)));
-                }
-                _ => {}
-            };
-        }
-    };
-}
-
 #[derive(Debug)]
 pub(super) enum LhsExpr {
     NotYetParsed,
@@ -1438,7 +1408,27 @@ impl<'a> Parser<'a> {
     /// correctly if called from `parse_dot_or_call_expr()`.
     fn parse_expr_bottom(&mut self) -> PResult<'a, P<Expr>> {
         maybe_recover_from_interpolated_ty_qpath!(self, true);
-        maybe_whole_expr!(self);
+
+        if let token::Interpolated(nt) = &self.token.kind {
+            match &**nt {
+                token::NtExpr(e) | token::NtLiteral(e) => {
+                    let e = e.clone();
+                    self.bump();
+                    return Ok(e);
+                }
+                token::NtPath(path) => {
+                    let path = (**path).clone();
+                    self.bump();
+                    return Ok(self.mk_expr(self.prev_token.span, ExprKind::Path(None, path)));
+                }
+                token::NtBlock(block) => {
+                    let block = block.clone();
+                    self.bump();
+                    return Ok(self.mk_expr(self.prev_token.span, ExprKind::Block(block, None)));
+                }
+                _ => {}
+            };
+        }
 
         // Outer attributes are already parsed and will be
         // added to the return value after the fact.
@@ -2207,7 +2197,27 @@ impl<'a> Parser<'a> {
     /// Matches `'-' lit | lit` (cf. `ast_validation::AstValidator::check_expr_within_pat`).
     /// Keep this in sync with `Token::can_begin_literal_maybe_minus`.
     pub fn parse_literal_maybe_minus(&mut self) -> PResult<'a, P<Expr>> {
-        maybe_whole_expr!(self);
+        let whole = if let token::Interpolated(nt) = &self.token.kind {
+            match &**nt {
+                token::NtLiteral(e) => Some(e.clone()),
+                token::NtExpr(e) => match &e.kind {
+                    ExprKind::Lit(_) => Some(e.clone()),
+                    ExprKind::Unary(UnOp::Neg, inner)
+                        if matches!(&inner.kind, ast::ExprKind::Lit(_)) =>
+                    {
+                        Some(e.clone())
+                    }
+                    _ => None,
+                },
+                _ => None,
+            }
+        } else {
+            None
+        };
+        if let Some(e) = whole {
+            self.bump();
+            return Ok(e);
+        }
 
         let lo = self.token.span;
         let minus_present = self.eat(&token::BinOp(token::Minus));

tests/ui/issues/issue-43250.rs

@@ -4,10 +4,10 @@ fn main() {
     macro_rules! m {
         ($a:expr) => {
             let $a = 0;
+            //~^ ERROR expected pattern, found expression `y`
+            //~| ERROR expected pattern, found expression `C`
         }
     }
     m!(y);
-    //~^ ERROR arbitrary expressions aren't allowed in patterns
     m!(C);
-    //~^ ERROR arbitrary expressions aren't allowed in patterns
 }

tests/ui/issues/issue-43250.stderr

@@ -1,18 +1,24 @@
-error: arbitrary expressions aren't allowed in patterns
-  --> $DIR/issue-43250.rs:9:8
+error: expected pattern, found expression `y`
+  --> $DIR/issue-43250.rs:6:17
    |
+LL |             let $a = 0;
+   |                 ^^ expected pattern
+...
 LL |     m!(y);
-   |        ^
+   |     ----- in this macro invocation
    |
-   = note: the `expr` fragment specifier forces the metavariable's content to be an expression
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: arbitrary expressions aren't allowed in patterns
-  --> $DIR/issue-43250.rs:11:8
+error: expected pattern, found expression `C`
+  --> $DIR/issue-43250.rs:6:17
    |
+LL |             let $a = 0;
+   |                 ^^ expected pattern
+...
 LL |     m!(C);
-   |        ^
+   |     ----- in this macro invocation
    |
-   = note: the `expr` fragment specifier forces the metavariable's content to be an expression
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 2 previous errors
 

tests/ui/lowering/expr-in-pat-issue-99380.rs

@@ -1,11 +1,11 @@
 macro_rules! foo {
     ($p:expr) => {
-        if let $p = Some(42) {
+        if let $p = Some(42) { //~ ERROR expected pattern, found expression `Some(3)`
             return;
         }
     };
 }
 
 fn main() {
-    foo!(Some(3)); //~ ERROR arbitrary expressions aren't allowed in patterns
+    foo!(Some(3));
 }

tests/ui/lowering/expr-in-pat-issue-99380.stderr

@@ -1,10 +1,13 @@
-error: arbitrary expressions aren't allowed in patterns
-  --> $DIR/expr-in-pat-issue-99380.rs:10:10
+error: expected pattern, found expression `Some(3)`
+  --> $DIR/expr-in-pat-issue-99380.rs:3:16
    |
+LL |         if let $p = Some(42) {
+   |                ^^ expected pattern
+...
 LL |     foo!(Some(3));
-   |          ^^^^^^^
+   |     ------------- in this macro invocation
    |
-   = note: the `expr` fragment specifier forces the metavariable's content to be an expression
+   = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
 

tests/ui/macros/trace_faulty_macros.rs

@@ -43,10 +43,10 @@ fn use_bang_macro_as_attr() {}
 fn use_derive_macro_as_attr() {}
 
 macro_rules! test {
-    (let $p:pat = $e:expr) => {test!(($p,$e))};
+    (let $p:pat = $e:expr) => {test!(($p,$e))}; //~ ERROR expected pattern, found expression `1+1`
     // this should be expr
     //           vvv
-    (($p:pat, $e:pat)) => {let $p = $e;}; //~ ERROR expected expression, found pattern `1+1`
+    (($p:pat, $e:pat)) => {let $p = $e;};
 }
 
 fn foo() {

tests/ui/macros/trace_faulty_macros.stderr

@@ -69,22 +69,18 @@ LL | #[derive(Debug)]
 LL | fn use_derive_macro_as_attr() {}
    | -------------------------------- not a `struct`, `enum` or `union`
 
-error: expected expression, found pattern `1+1`
-  --> $DIR/trace_faulty_macros.rs:49:37
+error: expected pattern, found expression `1+1`
+  --> $DIR/trace_faulty_macros.rs:46:42
    |
 LL |     (let $p:pat = $e:expr) => {test!(($p,$e))};
-   |                                          -- this is interpreted as expression, but it is expected to be pattern
+   |                                          ^^ expected pattern
 ...
 LL |     (($p:pat, $e:pat)) => {let $p = $e;};
-   |                                     ^^ expected expression
+   |               ------ while parsing argument for this `pat` macro fragment
 ...
 LL |     test!(let x = 1+1);
-   |     ------------------
-   |     |             |
-   |     |             this is expected to be expression
-   |     in this macro invocation
+   |     ------------------ in this macro invocation
    |
-   = note: when forwarding a matched fragment to another macro-by-example, matchers in the second macro will see an opaque AST of the fragment type, not the underlying tokens
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 note: trace_macro
@@ -107,7 +103,6 @@ LL |     test!(let x = 1+1);
    = note: expanding `test! { let x = 1+1 }`
    = note: to `test! ((x, 1+1))`
    = note: expanding `test! { (x, 1+1) }`
-   = note: to `let x = 1+1;`
 
 error: aborting due to 5 previous errors
 

tests/ui/macros/vec-macro-in-pattern.rs

@@ -4,7 +4,7 @@
 
 fn main() {
     match Some(vec![42]) {
-        Some(vec![43]) => {} //~ ERROR arbitrary expressions aren't allowed in patterns
+        Some(vec![43]) => {} //~ ERROR expected pattern, found expression
         _ => {}
     }
 }

tests/ui/macros/vec-macro-in-pattern.stderr

@@ -1,11 +1,14 @@
-error: arbitrary expressions aren't allowed in patterns
+error: expected pattern, found expression `< [_] > :: into_vec(#[rustc_box] $crate :: boxed :: Box :: new([43]))`
   --> $DIR/vec-macro-in-pattern.rs:7:14
    |
 LL |         Some(vec![43]) => {}
    |              ^^^^^^^^
+   |              |
+   |              expected pattern
+   |              in this macro invocation
+   |              this macro call doesn't expand to a pattern
    |
-   = note: the `expr` fragment specifier forces the metavariable's content to be an expression
-   = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__rust_force_expr` which comes from the expansion of the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
 

tests/ui/match/expr_before_ident_pat.rs

@@ -2,12 +2,11 @@ macro_rules! funny {
     ($a:expr, $b:ident) => {
         match [1, 2] {
             [$a, $b] => {}
+            //~^ ERROR expected pattern, found expression `a`
         }
     };
 }
 
 fn main() {
     funny!(a, a);
-    //~^ ERROR cannot find value `a` in this scope
-    //~| ERROR arbitrary expressions aren't allowed in patterns
 }

tests/ui/match/expr_before_ident_pat.stderr

@@ -1,17 +1,13 @@
-error[E0425]: cannot find value `a` in this scope
-  --> $DIR/expr_before_ident_pat.rs:10:12
+error: expected pattern, found expression `a`
+  --> $DIR/expr_before_ident_pat.rs:4:14
    |
+LL |             [$a, $b] => {}
+   |              ^^ expected pattern
+...
 LL |     funny!(a, a);
-   |            ^ not found in this scope
-
-error: arbitrary expressions aren't allowed in patterns
-  --> $DIR/expr_before_ident_pat.rs:10:12
-   |
-LL |     funny!(a, a);
-   |            ^
+   |     ------------ in this macro invocation
    |
-   = note: the `expr` fragment specifier forces the metavariable's content to be an expression
+   = note: this error originates in the macro `funny` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0425`.

tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.rs

@@ -4,21 +4,20 @@
 macro_rules! mac1 {
     ($eval:expr) => {
         let mut $eval = ();
-        //~^ ERROR `mut` must be followed by a named binding
+        //~^ ERROR expected identifier, found expression `does_not_exist!()`
     };
 }
 
 macro_rules! mac2 {
     ($eval:pat) => {
         let mut $eval = ();
-        //~^ ERROR `mut` must be followed by a named binding
-        //~| ERROR expected identifier, found `does_not_exist!()`
+        //~^ ERROR expected identifier, found `does_not_exist!()`
+        //~| ERROR `mut` must be followed by a named binding
     };
 }
 
 fn foo() {
     mac1! { does_not_exist!() }
-    //~^ ERROR cannot find macro `does_not_exist` in this scope
     mac2! { does_not_exist!() }
     //~^ ERROR cannot find macro `does_not_exist` in this scope
 }