diff options
20 files changed, 633 insertions, 282 deletions
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl index ec9a676ea31..3d0ce77bc47 100644 --- a/compiler/rustc_parse/messages.ftl +++ b/compiler/rustc_parse/messages.ftl @@ -803,15 +803,9 @@ parse_unexpected_expr_in_pat = expected {$is_bound -> [true] a pattern range bound *[false] a pattern - }, found {$is_method_call -> - [true] a method call - *[false] an expression - } + }, found an expression - .label = {$is_method_call -> - [true] method calls - *[false] arbitrary expressions - } are not allowed in patterns + .label = arbitrary expressions are not allowed in patterns parse_unexpected_if_with_if = unexpected `if` in the condition expression .suggestion = remove the `if` diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs index da1103a4fe5..a91aa1f5018 100644 --- a/compiler/rustc_parse/src/errors.rs +++ b/compiler/rustc_parse/src/errors.rs @@ -2597,8 +2597,6 @@ pub(crate) struct UnexpectedExpressionInPattern { pub span: Span, /// Was a `RangePatternBound` expected? pub is_bound: bool, - /// Was the unexpected expression a `MethodCallExpression`? - pub is_method_call: bool, } #[derive(Diagnostic)] diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs index 2d5a1914fa6..f19cba4c1bf 100644 --- a/compiler/rustc_parse/src/parser/expr.rs +++ b/compiler/rustc_parse/src/parser/expr.rs @@ -41,7 +41,7 @@ use super::{ use crate::{errors, maybe_recover_from_interpolated_ty_qpath}; #[derive(Debug)] -enum DestructuredFloat { +pub(super) enum DestructuredFloat { /// 1e2 Single(Symbol, Span), /// 1. @@ -1041,7 +1041,7 @@ impl<'a> Parser<'a> { // support pushing "future tokens" (would be also helpful to `break_and_eat`), or // we should break everything including floats into more basic proc-macro style // tokens in the lexer (probably preferable). - fn break_up_float(&self, float: Symbol, span: Span) -> DestructuredFloat { + pub(super) fn break_up_float(&self, float: Symbol, span: Span) -> DestructuredFloat { #[derive(Debug)] enum FloatComponent { IdentLike(String), diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs index daced411b8f..94c01f7e0d4 100644 --- a/compiler/rustc_parse/src/parser/pat.rs +++ b/compiler/rustc_parse/src/parser/pat.rs @@ -25,7 +25,7 @@ use crate::errors::{ UnexpectedParenInRangePat, UnexpectedParenInRangePatSugg, UnexpectedVertVertBeforeFunctionParam, UnexpectedVertVertInPattern, WrapInParens, }; -use crate::parser::expr::could_be_unclosed_char_literal; +use crate::parser::expr::{could_be_unclosed_char_literal, DestructuredFloat}; use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_whole}; #[derive(PartialEq, Copy, Clone)] @@ -342,7 +342,7 @@ impl<'a> Parser<'a> { } } - /// Ensures that the last parsed pattern (or pattern range bound) is not followed by a method call or an operator. + /// Ensures that the last parsed pattern (or pattern range bound) is not followed by an expression. /// /// `is_end_bound` indicates whether the last parsed thing was the end bound of a range pattern (see [`parse_pat_range_end`](Self::parse_pat_range_end)) /// in order to say "expected a pattern range bound" instead of "expected a pattern"; @@ -350,38 +350,64 @@ impl<'a> Parser<'a> { /// 0..=1 + 2 /// ^^^^^ /// ``` - /// Only the end bound is spanned, and this function have no idea if there were a `..=` before `pat_span`, hence the parameter. + /// Only the end bound is spanned in this case, and this function has no idea if there was a `..=` before `pat_span`, hence the parameter. + /// + /// This function returns `Some` if a trailing expression was recovered, and said expression's span. #[must_use = "the pattern must be discarded as `PatKind::Err` if this function returns Some"] fn maybe_recover_trailing_expr( &mut self, pat_span: Span, is_end_bound: bool, - ) -> Option<ErrorGuaranteed> { + ) -> Option<(ErrorGuaranteed, Span)> { if self.prev_token.is_keyword(kw::Underscore) || !self.may_recover() { // Don't recover anything after an `_` or if recovery is disabled. return None; } - // Check for `.hello()`, but allow `.Hello()` to be recovered as `, Hello()` in `parse_seq_to_before_tokens()`. - let has_trailing_method = self.check_noexpect(&token::Dot) + // Returns `true` iff `token` is an unsuffixed integer. + let is_one_tuple_index = |_: &Self, token: &Token| -> bool { + use token::{Lit, LitKind}; + + matches!( + token.kind, + token::Literal(Lit { kind: LitKind::Integer, symbol: _, suffix: None }) + ) + }; + + // Returns `true` iff `token` is an unsuffixed `x.y` float. + let is_two_tuple_indexes = |this: &Self, token: &Token| -> bool { + use token::{Lit, LitKind}; + + if let token::Literal(Lit { kind: LitKind::Float, symbol, suffix: None }) = token.kind + && let DestructuredFloat::MiddleDot(..) = this.break_up_float(symbol, token.span) + { + true + } else { + false + } + }; + + // Check for `.hello` or `.0`. + let has_dot_expr = self.check_noexpect(&token::Dot) // `.` && self.look_ahead(1, |tok| { - tok.ident() - .and_then(|(ident, _)| ident.name.as_str().chars().next()) - .is_some_and(char::is_lowercase) - }) - && self.look_ahead(2, |t| *t == token::OpenDelim(Delimiter::Parenthesis)); + tok.is_ident() // `hello` + || is_one_tuple_index(&self, &tok) // `0` + || is_two_tuple_indexes(&self, &tok) // `0.0` + }); // Check for operators. // `|` is excluded as it is used in pattern alternatives and lambdas, // `?` is included for error propagation, // `[` is included for indexing operations, - // `[]` is excluded as `a[]` isn't an expression and should be recovered as `a, []` (cf. `tests/ui/parser/pat-lt-bracket-7.rs`) + // `[]` is excluded as `a[]` isn't an expression and should be recovered as `a, []` (cf. `tests/ui/parser/pat-lt-bracket-7.rs`), + // `as` is included for type casts let has_trailing_operator = matches!(self.token.kind, token::BinOp(op) if op != BinOpToken::Or) || self.token == token::Question || (self.token == token::OpenDelim(Delimiter::Bracket) - && self.look_ahead(1, |t| *t != token::CloseDelim(Delimiter::Bracket))); + && self.look_ahead(1, |t| *t != token::CloseDelim(Delimiter::Bracket))) // excludes `[]` + || self.token.is_keyword(kw::As); - if !has_trailing_method && !has_trailing_operator { + if !has_dot_expr && !has_trailing_operator { // Nothing to recover here. return None; } @@ -391,44 +417,41 @@ impl<'a> Parser<'a> { snapshot.restrictions.insert(Restrictions::IS_PAT); // Parse `?`, `.f`, `(arg0, arg1, ...)` or `[expr]` until they've all been eaten. - if let Ok(expr) = snapshot + let Ok(expr) = snapshot .parse_expr_dot_or_call_with( AttrVec::new(), self.mk_expr(pat_span, ExprKind::Dummy), // equivalent to transforming the parsed pattern into an `Expr` pat_span, ) .map_err(|err| err.cancel()) - { - let non_assoc_span = expr.span; + else { + // We got a trailing method/operator, but that wasn't an expression. + return None; + }; - // Parse an associative expression such as `+ expr`, `% expr`, ... - // Assignments, ranges and `|` are disabled by [`Restrictions::IS_PAT`]. - if let Ok((expr, _)) = - snapshot.parse_expr_assoc_rest_with(0, false, expr).map_err(|err| err.cancel()) - { - // We got a valid expression. - self.restore_snapshot(snapshot); - self.restrictions.remove(Restrictions::IS_PAT); - - let is_bound = is_end_bound - // is_start_bound: either `..` or `)..` - || self.token.is_range_separator() - || self.token == token::CloseDelim(Delimiter::Parenthesis) - && self.look_ahead(1, Token::is_range_separator); - - // Check that `parse_expr_assoc_with` didn't eat a rhs. - let is_method_call = has_trailing_method && non_assoc_span == expr.span; - - return Some(self.dcx().emit_err(UnexpectedExpressionInPattern { - span: expr.span, - is_bound, - is_method_call, - })); - } - } + // Parse an associative expression such as `+ expr`, `% expr`, ... + // Assignments, ranges and `|` are disabled by [`Restrictions::IS_PAT`]. + let Ok((expr, _)) = + snapshot.parse_expr_assoc_rest_with(0, false, expr).map_err(|err| err.cancel()) + else { + // We got a trailing method/operator, but that wasn't an expression. + return None; + }; - // We got a trailing method/operator, but we couldn't parse an expression. - None + // We got a valid expression. + self.restore_snapshot(snapshot); + self.restrictions.remove(Restrictions::IS_PAT); + + let is_bound = is_end_bound + // is_start_bound: either `..` or `)..` + || self.token.is_range_separator() + || self.token == token::CloseDelim(Delimiter::Parenthesis) + && self.look_ahead(1, Token::is_range_separator); + + Some(( + self.dcx().emit_err(UnexpectedExpressionInPattern { span: expr.span, is_bound }), + expr.span, + )) } /// Parses a pattern, with a setting whether modern range patterns (e.g., `a..=b`, `a..b` are @@ -544,7 +567,7 @@ impl<'a> Parser<'a> { self.parse_pat_tuple_struct(qself, path)? } else { match self.maybe_recover_trailing_expr(span, false) { - Some(guar) => PatKind::Err(guar), + Some((guar, _)) => PatKind::Err(guar), None => PatKind::Path(qself, path), } } @@ -577,10 +600,10 @@ impl<'a> Parser<'a> { // Try to parse everything else as literal with optional minus match self.parse_literal_maybe_minus() { Ok(begin) => { - let begin = match self.maybe_recover_trailing_expr(begin.span, false) { - Some(guar) => self.mk_expr_err(begin.span, guar), - None => begin, - }; + let begin = self + .maybe_recover_trailing_expr(begin.span, false) + .map(|(guar, sp)| self.mk_expr_err(sp, guar)) + .unwrap_or(begin); match self.parse_range_end() { Some(form) => self.parse_pat_range_begin_with(begin, form)?, @@ -721,7 +744,8 @@ impl<'a> Parser<'a> { // For backward compatibility, `(..)` is a tuple pattern as well. let paren_pattern = fields.len() == 1 && !(matches!(trailing_comma, Trailing::Yes) || fields[0].is_rest()); - if paren_pattern { + + let pat = if paren_pattern { let pat = fields.into_iter().next().unwrap(); let close_paren = self.prev_token.span; @@ -739,7 +763,7 @@ impl<'a> Parser<'a> { }, }); - self.parse_pat_range_begin_with(begin.clone(), form) + self.parse_pat_range_begin_with(begin.clone(), form)? } // recover ranges with parentheses around the `(start)..` PatKind::Err(guar) @@ -754,15 +778,20 @@ impl<'a> Parser<'a> { }, }); - self.parse_pat_range_begin_with(self.mk_expr_err(pat.span, *guar), form) + self.parse_pat_range_begin_with(self.mk_expr_err(pat.span, *guar), form)? } // (pat) with optional parentheses - _ => Ok(PatKind::Paren(pat)), + _ => PatKind::Paren(pat), } } else { - Ok(PatKind::Tuple(fields)) - } + PatKind::Tuple(fields) + }; + + Ok(match self.maybe_recover_trailing_expr(open_paren.to(self.prev_token.span), false) { + None => pat, + Some((guar, _)) => PatKind::Err(guar), + }) } /// Parse a mutable binding with the `mut` token already eaten. @@ -1015,7 +1044,7 @@ impl<'a> Parser<'a> { } Ok(match recovered { - Some(guar) => self.mk_expr_err(bound.span, guar), + Some((guar, sp)) => self.mk_expr_err(sp, guar), None => bound, }) } @@ -1084,7 +1113,7 @@ impl<'a> Parser<'a> { // but not `ident @ subpat` as `subpat` was already checked and `ident` continues with `@`. let pat = if sub.is_none() - && let Some(guar) = self.maybe_recover_trailing_expr(ident.span, false) + && let Some((guar, _)) = self.maybe_recover_trailing_expr(ident.span, false) { PatKind::Err(guar) } else { diff --git a/tests/ui/parser/bad-name.rs b/tests/ui/parser/bad-name.rs index 59432a1d9a5..fefe9122a08 100644 --- a/tests/ui/parser/bad-name.rs +++ b/tests/ui/parser/bad-name.rs @@ -1,5 +1,6 @@ -//@ error-pattern: expected - fn main() { let x.y::<isize>.z foo; + //~^ error: field expressions cannot have generic arguments + //~| error: expected a pattern, found an expression + //~| error: expected one of `(`, `.`, `::`, `:`, `;`, `=`, `?`, `|`, or an operator, found `foo` } diff --git a/tests/ui/parser/bad-name.stderr b/tests/ui/parser/bad-name.stderr index e133d4e4839..3fc416dd531 100644 --- a/tests/ui/parser/bad-name.stderr +++ b/tests/ui/parser/bad-name.stderr @@ -1,8 +1,20 @@ -error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` - --> $DIR/bad-name.rs:4:8 +error: field expressions cannot have generic arguments + --> $DIR/bad-name.rs:2:12 | LL | let x.y::<isize>.z foo; - | ^ expected one of `:`, `;`, `=`, `@`, or `|` + | ^^^^^^^ -error: aborting due to 1 previous error +error: expected a pattern, found an expression + --> $DIR/bad-name.rs:2:7 + | +LL | let x.y::<isize>.z foo; + | ^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected one of `(`, `.`, `::`, `:`, `;`, `=`, `?`, `|`, or an operator, found `foo` + --> $DIR/bad-name.rs:2:22 + | +LL | let x.y::<isize>.z foo; + | ^^^ expected one of 9 possible tokens + +error: aborting due to 3 previous errors diff --git a/tests/ui/parser/pat-recover-exprs.rs b/tests/ui/parser/pat-recover-exprs.rs deleted file mode 100644 index ecd471467e3..00000000000 --- a/tests/ui/parser/pat-recover-exprs.rs +++ /dev/null @@ -1,28 +0,0 @@ -fn main() { - match u8::MAX { - u8::MAX.abs() => (), - //~^ error: expected a pattern, found a method call - x.sqrt() @ .. => (), - //~^ error: expected a pattern, found a method call - //~| error: left-hand side of `@` must be a binding - z @ w @ v.u() => (), - //~^ error: expected a pattern, found a method call - y.ilog(3) => (), - //~^ error: expected a pattern, found a method call - n + 1 => (), - //~^ error: expected a pattern, found an expression - ("".f() + 14 * 8) => (), - //~^ error: expected a pattern, found an expression - 0 | ((1) | 2) | 3 => (), - f?() => (), - //~^ error: expected a pattern, found an expression - (_ + 1) => (), - //~^ error: expected one of `)`, `,`, or `|`, found `+` - } - - let 1 + 1 = 2; - //~^ error: expected a pattern, found an expression - - let b = matches!(x, (x * x | x.f()) | x[0]); - //~^ error: expected one of `)`, `,`, `@`, or `|`, found `*` -} diff --git a/tests/ui/parser/pat-recover-exprs.stderr b/tests/ui/parser/pat-recover-exprs.stderr deleted file mode 100644 index 787fd03b0c3..00000000000 --- a/tests/ui/parser/pat-recover-exprs.stderr +++ /dev/null @@ -1,76 +0,0 @@ -error: expected a pattern, found a method call - --> $DIR/pat-recover-exprs.rs:3:9 - | -LL | u8::MAX.abs() => (), - | ^^^^^^^^^^^^^ method calls are not allowed in patterns - -error: expected a pattern, found a method call - --> $DIR/pat-recover-exprs.rs:5:9 - | -LL | x.sqrt() @ .. => (), - | ^^^^^^^^ method calls are not allowed in patterns - -error: left-hand side of `@` must be a binding - --> $DIR/pat-recover-exprs.rs:5:9 - | -LL | x.sqrt() @ .. => (), - | --------^^^-- - | | | - | | also a pattern - | interpreted as a pattern, not a binding - | - = note: bindings are `x`, `mut x`, `ref x`, and `ref mut x` - -error: expected a pattern, found a method call - --> $DIR/pat-recover-exprs.rs:8:17 - | -LL | z @ w @ v.u() => (), - | ^^^^^ method calls are not allowed in patterns - -error: expected a pattern, found a method call - --> $DIR/pat-recover-exprs.rs:10:9 - | -LL | y.ilog(3) => (), - | ^^^^^^^^^ method calls are not allowed in patterns - -error: expected a pattern, found an expression - --> $DIR/pat-recover-exprs.rs:12:9 - | -LL | n + 1 => (), - | ^^^^^ arbitrary expressions are not allowed in patterns - -error: expected a pattern, found an expression - --> $DIR/pat-recover-exprs.rs:14:10 - | -LL | ("".f() + 14 * 8) => (), - | ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns - -error: expected a pattern, found an expression - --> $DIR/pat-recover-exprs.rs:17:9 - | -LL | f?() => (), - | ^^^^ arbitrary expressions are not allowed in patterns - -error: expected one of `)`, `,`, or `|`, found `+` - --> $DIR/pat-recover-exprs.rs:19:12 - | -LL | (_ + 1) => (), - | ^ expected one of `)`, `,`, or `|` - -error: expected a pattern, found an expression - --> $DIR/pat-recover-exprs.rs:23:9 - | -LL | let 1 + 1 = 2; - | ^^^^^ arbitrary expressions are not allowed in patterns - -error: expected one of `)`, `,`, `@`, or `|`, found `*` - --> $DIR/pat-recover-exprs.rs:26:28 - | -LL | let b = matches!(x, (x * x | x.f()) | x[0]); - | ^ expected one of `)`, `,`, `@`, or `|` - --> $SRC_DIR/core/src/macros/mod.rs:LL:COL - | - = note: while parsing argument for this `pat` macro fragment - -error: aborting due to 11 previous errors - diff --git a/tests/ui/parser/pat-recover-methodcalls.rs b/tests/ui/parser/pat-recover-methodcalls.rs deleted file mode 100644 index 54104e9a535..00000000000 --- a/tests/ui/parser/pat-recover-methodcalls.rs +++ /dev/null @@ -1,37 +0,0 @@ -struct Foo(String); -struct Bar { baz: String } - -fn foo(foo: Foo) -> bool { - match foo { - Foo("hi".to_owned()) => true, - //~^ error: expected a pattern, found a method call - _ => false - } -} - -fn bar(bar: Bar) -> bool { - match bar { - Bar { baz: "hi".to_owned() } => true, - //~^ error: expected a pattern, found a method call - _ => false - } -} - -fn baz() { // issue #90121 - let foo = vec!["foo".to_string()]; - - match foo.as_slice() { - &["foo".to_string()] => {} - //~^ error: expected a pattern, found a method call - _ => {} - }; -} - -fn main() { - if let (-1.some(4)) = (0, Some(4)) {} - //~^ error: expected a pattern, found a method call - - if let (-1.Some(4)) = (0, Some(4)) {} - //~^ error: expected one of `)`, `,`, `...`, `..=`, `..`, or `|`, found `.` - //~| help: missing `,` -} diff --git a/tests/ui/parser/pat-recover-methodcalls.stderr b/tests/ui/parser/pat-recover-methodcalls.stderr deleted file mode 100644 index 1f9ae81dc0c..00000000000 --- a/tests/ui/parser/pat-recover-methodcalls.stderr +++ /dev/null @@ -1,35 +0,0 @@ -error: expected a pattern, found a method call - --> $DIR/pat-recover-methodcalls.rs:6:13 - | -LL | Foo("hi".to_owned()) => true, - | ^^^^^^^^^^^^^^^ method calls are not allowed in patterns - -error: expected a pattern, found a method call - --> $DIR/pat-recover-methodcalls.rs:14:20 - | -LL | Bar { baz: "hi".to_owned() } => true, - | ^^^^^^^^^^^^^^^ method calls are not allowed in patterns - -error: expected a pattern, found a method call - --> $DIR/pat-recover-methodcalls.rs:24:11 - | -LL | &["foo".to_string()] => {} - | ^^^^^^^^^^^^^^^^^ method calls are not allowed in patterns - -error: expected a pattern, found a method call - --> $DIR/pat-recover-methodcalls.rs:31:13 - | -LL | if let (-1.some(4)) = (0, Some(4)) {} - | ^^^^^^^^^^ method calls are not allowed in patterns - -error: expected one of `)`, `,`, `...`, `..=`, `..`, or `|`, found `.` - --> $DIR/pat-recover-methodcalls.rs:34:15 - | -LL | if let (-1.Some(4)) = (0, Some(4)) {} - | ^ - | | - | expected one of `)`, `,`, `...`, `..=`, `..`, or `|` - | help: missing `,` - -error: aborting due to 5 previous errors - diff --git a/tests/ui/parser/recover/recover-pat-exprs.rs b/tests/ui/parser/recover/recover-pat-exprs.rs new file mode 100644 index 00000000000..031e49cb8eb --- /dev/null +++ b/tests/ui/parser/recover/recover-pat-exprs.rs @@ -0,0 +1,98 @@ +// FieldExpression, TupleIndexingExpression +fn field_access() { + match 0 { + x => (), + x.y => (), //~ error: expected a pattern, found an expression + x.0 => (), //~ error: expected a pattern, found an expression + x._0 => (), //~ error: expected a pattern, found an expression + x.0.1 => (), //~ error: expected a pattern, found an expression + x.4.y.17.__z => (), //~ error: expected a pattern, found an expression + } + + { let x.0e0; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` + { let x.-0.0; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` + { let x.-0; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` + + { let x.0u32; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` + { let x.0.0_f64; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` +} + +// IndexExpression, ArrayExpression +fn array_indexing() { + match 0 { + x[0] => (), //~ error: expected a pattern, found an expression + x[..] => (), //~ error: expected a pattern, found an expression + } + + { let x[0, 1, 2]; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[` + { let x[0; 20]; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[` + { let x[]; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[` + { let (x[]); } //~ error: expected one of `)`, `,`, `@`, or `|`, found `[` + //~^ missing `,` +} + +// MethodCallExpression, CallExpression, ErrorPropagationExpression +fn method_call() { + match 0 { + x.f() => (), //~ error: expected a pattern, found an expression + x._f() => (), //~ error: expected a pattern, found an expression + x? => (), //~ error: expected a pattern, found an expression + ().f() => (), //~ error: expected a pattern, found an expression + (0, x)?.f() => (), //~ error: expected a pattern, found an expression + x.f().g() => (), //~ error: expected a pattern, found an expression + 0.f()?.g()?? => (), //~ error: expected a pattern, found an expression + } +} + +// TypeCastExpression +fn type_cast() { + match 0 { + x as usize => (), //~ error: expected a pattern, found an expression + 0 as usize => (), //~ error: expected a pattern, found an expression + x.f().0.4 as f32 => (), //~ error: expected a pattern, found an expression + } +} + +// ArithmeticOrLogicalExpression +fn operator() { + match 0 { + 1 + 1 => (), //~ error: expected a pattern, found an expression + (1 + 2) * 3 => (), + //~^ error: expected a pattern, found an expression + //~| error: expected a pattern, found an expression + } +} + +const _: u32 = match 12 { + 1 + 2 * PI.cos() => 2, //~ error: expected a pattern, found an expression + _ => 0, +}; + +fn main() { + match u8::MAX { + u8::MAX.abs() => (), + //~^ error: expected a pattern, found an expression + x.sqrt() @ .. => (), + //~^ error: expected a pattern, found an expression + //~| error: left-hand side of `@` must be a binding + z @ w @ v.u() => (), + //~^ error: expected a pattern, found an expression + y.ilog(3) => (), + //~^ error: expected a pattern, found an expression + n + 1 => (), + //~^ error: expected a pattern, found an expression + ("".f() + 14 * 8) => (), + //~^ error: expected a pattern, found an expression + 0 | ((1) | 2) | 3 => (), + f?() => (), + //~^ error: expected a pattern, found an expression + (_ + 1) => (), + //~^ error: expected one of `)`, `,`, or `|`, found `+` + } + + let 1 + 1 = 2; + //~^ error: expected a pattern, found an expression + + let b = matches!(x, (x * x | x.f()) | x[0]); + //~^ error: expected one of `)`, `,`, `@`, or `|`, found `*` +} diff --git a/tests/ui/parser/recover/recover-pat-exprs.stderr b/tests/ui/parser/recover/recover-pat-exprs.stderr new file mode 100644 index 00000000000..ea8d1458d27 --- /dev/null +++ b/tests/ui/parser/recover/recover-pat-exprs.stderr @@ -0,0 +1,259 @@ +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:5:9 + | +LL | x.y => (), + | ^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:6:9 + | +LL | x.0 => (), + | ^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:7:9 + | +LL | x._0 => (), + | ^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:8:9 + | +LL | x.0.1 => (), + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:9:9 + | +LL | x.4.y.17.__z => (), + | ^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` + --> $DIR/recover-pat-exprs.rs:12:12 + | +LL | { let x.0e0; } + | ^ expected one of `:`, `;`, `=`, `@`, or `|` + +error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` + --> $DIR/recover-pat-exprs.rs:13:12 + | +LL | { let x.-0.0; } + | ^ expected one of `:`, `;`, `=`, `@`, or `|` + +error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` + --> $DIR/recover-pat-exprs.rs:14:12 + | +LL | { let x.-0; } + | ^ expected one of `:`, `;`, `=`, `@`, or `|` + +error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` + --> $DIR/recover-pat-exprs.rs:16:12 + | +LL | { let x.0u32; } + | ^ expected one of `:`, `;`, `=`, `@`, or `|` + +error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.` + --> $DIR/recover-pat-exprs.rs:17:12 + | +LL | { let x.0.0_f64; } + | ^ expected one of `:`, `;`, `=`, `@`, or `|` + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:23:9 + | +LL | x[0] => (), + | ^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:24:9 + | +LL | x[..] => (), + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[` + --> $DIR/recover-pat-exprs.rs:27:12 + | +LL | { let x[0, 1, 2]; } + | ^ expected one of `:`, `;`, `=`, `@`, or `|` + +error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[` + --> $DIR/recover-pat-exprs.rs:28:12 + | +LL | { let x[0; 20]; } + | ^ expected one of `:`, `;`, `=`, `@`, or `|` + +error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[` + --> $DIR/recover-pat-exprs.rs:29:12 + | +LL | { let x[]; } + | ^ expected one of `:`, `;`, `=`, `@`, or `|` + +error: expected one of `)`, `,`, `@`, or `|`, found `[` + --> $DIR/recover-pat-exprs.rs:30:13 + | +LL | { let (x[]); } + | ^ + | | + | expected one of `)`, `,`, `@`, or `|` + | help: missing `,` + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:37:9 + | +LL | x.f() => (), + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:38:9 + | +LL | x._f() => (), + | ^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:39:9 + | +LL | x? => (), + | ^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:40:9 + | +LL | ().f() => (), + | ^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:41:9 + | +LL | (0, x)?.f() => (), + | ^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:42:9 + | +LL | x.f().g() => (), + | ^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:43:9 + | +LL | 0.f()?.g()?? => (), + | ^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:50:9 + | +LL | x as usize => (), + | ^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:51:9 + | +LL | 0 as usize => (), + | ^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:52:9 + | +LL | x.f().0.4 as f32 => (), + | ^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:59:9 + | +LL | 1 + 1 => (), + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:60:10 + | +LL | (1 + 2) * 3 => (), + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:60:9 + | +LL | (1 + 2) * 3 => (), + | ^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:67:5 + | +LL | 1 + 2 * PI.cos() => 2, + | ^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:73:9 + | +LL | u8::MAX.abs() => (), + | ^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:75:9 + | +LL | x.sqrt() @ .. => (), + | ^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: left-hand side of `@` must be a binding + --> $DIR/recover-pat-exprs.rs:75:9 + | +LL | x.sqrt() @ .. => (), + | --------^^^-- + | | | + | | also a pattern + | interpreted as a pattern, not a binding + | + = note: bindings are `x`, `mut x`, `ref x`, and `ref mut x` + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:78:17 + | +LL | z @ w @ v.u() => (), + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:80:9 + | +LL | y.ilog(3) => (), + | ^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:82:9 + | +LL | n + 1 => (), + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:84:10 + | +LL | ("".f() + 14 * 8) => (), + | ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:87:9 + | +LL | f?() => (), + | ^^^^ arbitrary expressions are not allowed in patterns + +error: expected one of `)`, `,`, or `|`, found `+` + --> $DIR/recover-pat-exprs.rs:89:12 + | +LL | (_ + 1) => (), + | ^ expected one of `)`, `,`, or `|` + +error: expected a pattern, found an expression + --> $DIR/recover-pat-exprs.rs:93:9 + | +LL | let 1 + 1 = 2; + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: expected one of `)`, `,`, `@`, or `|`, found `*` + --> $DIR/recover-pat-exprs.rs:96:28 + | +LL | let b = matches!(x, (x * x | x.f()) | x[0]); + | ^ expected one of `)`, `,`, `@`, or `|` + --> $SRC_DIR/core/src/macros/mod.rs:LL:COL + | + = note: while parsing argument for this `pat` macro fragment + +error: aborting due to 41 previous errors + diff --git a/tests/ui/parser/recover/recover-pat-issues.rs b/tests/ui/parser/recover/recover-pat-issues.rs new file mode 100644 index 00000000000..5b900fe80e5 --- /dev/null +++ b/tests/ui/parser/recover/recover-pat-issues.rs @@ -0,0 +1,46 @@ +struct Foo(String); +struct Bar { baz: String } + +fn foo(foo: Foo) -> bool { + match foo { + Foo("hi".to_owned()) => true, + //~^ error: expected a pattern, found an expression + _ => false + } +} + +fn bar(bar: Bar) -> bool { + match bar { + Bar { baz: "hi".to_owned() } => true, + //~^ error: expected a pattern, found an expression + _ => false + } +} + +/// Issue #90121 +fn baz() { + let foo = vec!["foo".to_string()]; + + match foo.as_slice() { + &["foo".to_string()] => {} + //~^ error: expected a pattern, found an expression + _ => {} + }; +} + +/// Issue #104996 +fn qux() { + struct Magic(pub u16); + const MAGIC: Magic = Magic(42); + + if let Some(MAGIC.0 as usize) = None::<usize> {} + //~^ error: expected a pattern, found an expression +} + +fn main() { + if let (-1.some(4)) = (0, Some(4)) {} + //~^ error: expected a pattern, found an expression + + if let (-1.Some(4)) = (0, Some(4)) {} + //~^ error: expected a pattern, found an expression +} diff --git a/tests/ui/parser/recover/recover-pat-issues.stderr b/tests/ui/parser/recover/recover-pat-issues.stderr new file mode 100644 index 00000000000..793091bb1f1 --- /dev/null +++ b/tests/ui/parser/recover/recover-pat-issues.stderr @@ -0,0 +1,38 @@ +error: expected a pattern, found an expression + --> $DIR/recover-pat-issues.rs:6:13 + | +LL | Foo("hi".to_owned()) => true, + | ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-issues.rs:14:20 + | +LL | Bar { baz: "hi".to_owned() } => true, + | ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-issues.rs:25:11 + | +LL | &["foo".to_string()] => {} + | ^^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-issues.rs:36:17 + | +LL | if let Some(MAGIC.0 as usize) = None::<usize> {} + | ^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-issues.rs:41:13 + | +LL | if let (-1.some(4)) = (0, Some(4)) {} + | ^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-issues.rs:44:13 + | +LL | if let (-1.Some(4)) = (0, Some(4)) {} + | ^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: aborting due to 6 previous errors + diff --git a/tests/ui/parser/recover/recover-pat-lets.rs b/tests/ui/parser/recover/recover-pat-lets.rs new file mode 100644 index 00000000000..6681cc25db3 --- /dev/null +++ b/tests/ui/parser/recover/recover-pat-lets.rs @@ -0,0 +1,20 @@ +fn main() { + let x = Some(2); + + let x.expect("foo"); + //~^ error: expected a pattern, found an expression + + let x.unwrap(): u32; + //~^ error: expected a pattern, found an expression + + let x[0] = 1; + //~^ error: expected a pattern, found an expression + + let Some(1 + 1) = x else { //~ error: expected a pattern, found an expression + return; + }; + + if let Some(1 + 1) = x { //~ error: expected a pattern, found an expression + return; + } +} diff --git a/tests/ui/parser/recover/recover-pat-lets.stderr b/tests/ui/parser/recover/recover-pat-lets.stderr new file mode 100644 index 00000000000..b1d2a9b96d9 --- /dev/null +++ b/tests/ui/parser/recover/recover-pat-lets.stderr @@ -0,0 +1,32 @@ +error: expected a pattern, found an expression + --> $DIR/recover-pat-lets.rs:4:9 + | +LL | let x.expect("foo"); + | ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-lets.rs:7:9 + | +LL | let x.unwrap(): u32; + | ^^^^^^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-lets.rs:10:9 + | +LL | let x[0] = 1; + | ^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-lets.rs:13:14 + | +LL | let Some(1 + 1) = x else { + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: expected a pattern, found an expression + --> $DIR/recover-pat-lets.rs:17:17 + | +LL | if let Some(1 + 1) = x { + | ^^^^^ arbitrary expressions are not allowed in patterns + +error: aborting due to 5 previous errors + diff --git a/tests/ui/parser/pat-recover-ranges.rs b/tests/ui/parser/recover/recover-pat-ranges.rs index 7d77e950d90..e3f061c625d 100644 --- a/tests/ui/parser/pat-recover-ranges.rs +++ b/tests/ui/parser/recover/recover-pat-ranges.rs @@ -22,8 +22,8 @@ fn main() { //~| warning: `...` range patterns are deprecated //~| warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! 0.x()..="y".z() => (), - //~^ error: expected a pattern range bound, found a method call - //~| error: expected a pattern range bound, found a method call + //~^ error: expected a pattern range bound, found an expression + //~| error: expected a pattern range bound, found an expression }; } diff --git a/tests/ui/parser/pat-recover-ranges.stderr b/tests/ui/parser/recover/recover-pat-ranges.stderr index a7d62bd7f8a..62ef7a8a908 100644 --- a/tests/ui/parser/pat-recover-ranges.stderr +++ b/tests/ui/parser/recover/recover-pat-ranges.stderr @@ -1,5 +1,5 @@ error: range pattern bounds cannot have parentheses - --> $DIR/pat-recover-ranges.rs:4:13 + --> $DIR/recover-pat-ranges.rs:4:13 | LL | 0..=(1) => (), | ^ ^ @@ -11,7 +11,7 @@ LL + 0..=1 => (), | error: range pattern bounds cannot have parentheses - --> $DIR/pat-recover-ranges.rs:6:9 + --> $DIR/recover-pat-ranges.rs:6:9 | LL | (-12)..=4 => (), | ^ ^ @@ -23,7 +23,7 @@ LL + -12..=4 => (), | error: range pattern bounds cannot have parentheses - --> $DIR/pat-recover-ranges.rs:8:9 + --> $DIR/recover-pat-ranges.rs:8:9 | LL | (0)..=(-4) => (), | ^ ^ @@ -35,7 +35,7 @@ LL + 0..=(-4) => (), | error: range pattern bounds cannot have parentheses - --> $DIR/pat-recover-ranges.rs:8:15 + --> $DIR/recover-pat-ranges.rs:8:15 | LL | (0)..=(-4) => (), | ^ ^ @@ -47,13 +47,13 @@ LL + (0)..=-4 => (), | error: expected a pattern range bound, found an expression - --> $DIR/pat-recover-ranges.rs:11:12 + --> $DIR/recover-pat-ranges.rs:11:12 | LL | ..=1 + 2 => (), | ^^^^^ arbitrary expressions are not allowed in patterns error: range pattern bounds cannot have parentheses - --> $DIR/pat-recover-ranges.rs:13:9 + --> $DIR/recover-pat-ranges.rs:13:9 | LL | (4).. => (), | ^ ^ @@ -65,13 +65,13 @@ LL + 4.. => (), | error: expected a pattern range bound, found an expression - --> $DIR/pat-recover-ranges.rs:15:10 + --> $DIR/recover-pat-ranges.rs:15:10 | LL | (-4 + 0).. => (), | ^^^^^^ arbitrary expressions are not allowed in patterns error: range pattern bounds cannot have parentheses - --> $DIR/pat-recover-ranges.rs:15:9 + --> $DIR/recover-pat-ranges.rs:15:9 | LL | (-4 + 0).. => (), | ^ ^ @@ -83,13 +83,13 @@ LL + -4 + 0.. => (), | error: expected a pattern range bound, found an expression - --> $DIR/pat-recover-ranges.rs:18:10 + --> $DIR/recover-pat-ranges.rs:18:10 | LL | (1 + 4)...1 * 2 => (), | ^^^^^ arbitrary expressions are not allowed in patterns error: range pattern bounds cannot have parentheses - --> $DIR/pat-recover-ranges.rs:18:9 + --> $DIR/recover-pat-ranges.rs:18:9 | LL | (1 + 4)...1 * 2 => (), | ^ ^ @@ -101,25 +101,25 @@ LL + 1 + 4...1 * 2 => (), | error: expected a pattern range bound, found an expression - --> $DIR/pat-recover-ranges.rs:18:19 + --> $DIR/recover-pat-ranges.rs:18:19 | LL | (1 + 4)...1 * 2 => (), | ^^^^^ arbitrary expressions are not allowed in patterns -error: expected a pattern range bound, found a method call - --> $DIR/pat-recover-ranges.rs:24:9 +error: expected a pattern range bound, found an expression + --> $DIR/recover-pat-ranges.rs:24:9 | LL | 0.x()..="y".z() => (), - | ^^^^^ method calls are not allowed in patterns + | ^^^^^ arbitrary expressions are not allowed in patterns -error: expected a pattern range bound, found a method call - --> $DIR/pat-recover-ranges.rs:24:17 +error: expected a pattern range bound, found an expression + --> $DIR/recover-pat-ranges.rs:24:17 | LL | 0.x()..="y".z() => (), - | ^^^^^^^ method calls are not allowed in patterns + | ^^^^^^^ arbitrary expressions are not allowed in patterns warning: `...` range patterns are deprecated - --> $DIR/pat-recover-ranges.rs:18:16 + --> $DIR/recover-pat-ranges.rs:18:16 | LL | (1 + 4)...1 * 2 => (), | ^^^ help: use `..=` for an inclusive range diff --git a/tests/ui/parser/pat-recover-wildcards.rs b/tests/ui/parser/recover/recover-pat-wildcards.rs index f506e2223d6..f506e2223d6 100644 --- a/tests/ui/parser/pat-recover-wildcards.rs +++ b/tests/ui/parser/recover/recover-pat-wildcards.rs diff --git a/tests/ui/parser/pat-recover-wildcards.stderr b/tests/ui/parser/recover/recover-pat-wildcards.stderr index e36ff237bb0..64d477fdeb2 100644 --- a/tests/ui/parser/pat-recover-wildcards.stderr +++ b/tests/ui/parser/recover/recover-pat-wildcards.stderr @@ -1,35 +1,35 @@ error: expected one of `=>`, `if`, or `|`, found `+` - --> $DIR/pat-recover-wildcards.rs:5:11 + --> $DIR/recover-pat-wildcards.rs:5:11 | LL | _ + 1 => () | ^ expected one of `=>`, `if`, or `|` error: expected one of `)`, `,`, or `|`, found `%` - --> $DIR/pat-recover-wildcards.rs:11:12 + --> $DIR/recover-pat-wildcards.rs:11:12 | LL | (_ % 4) => () | ^ expected one of `)`, `,`, or `|` error: expected one of `=>`, `if`, or `|`, found `.` - --> $DIR/pat-recover-wildcards.rs:17:10 + --> $DIR/recover-pat-wildcards.rs:17:10 | LL | _.x() => () | ^ expected one of `=>`, `if`, or `|` error: expected one of `=>`, `if`, or `|`, found `..=` - --> $DIR/pat-recover-wildcards.rs:23:10 + --> $DIR/recover-pat-wildcards.rs:23:10 | LL | _..=4 => () | ^^^ expected one of `=>`, `if`, or `|` error: expected one of `=>`, `if`, or `|`, found reserved identifier `_` - --> $DIR/pat-recover-wildcards.rs:29:11 + --> $DIR/recover-pat-wildcards.rs:29:11 | LL | .._ => () | ^ expected one of `=>`, `if`, or `|` error[E0586]: inclusive range with no end - --> $DIR/pat-recover-wildcards.rs:35:10 + --> $DIR/recover-pat-wildcards.rs:35:10 | LL | 0..._ => () | ^^^ @@ -42,31 +42,31 @@ LL + 0.._ => () | error: expected one of `=>`, `if`, or `|`, found reserved identifier `_` - --> $DIR/pat-recover-wildcards.rs:35:13 + --> $DIR/recover-pat-wildcards.rs:35:13 | LL | 0..._ => () | ^ expected one of `=>`, `if`, or `|` error: expected one of `)`, `,`, or `|`, found `*` - --> $DIR/pat-recover-wildcards.rs:43:12 + --> $DIR/recover-pat-wildcards.rs:43:12 | LL | (_ * 0)..5 => () | ^ expected one of `)`, `,`, or `|` error: expected one of `=>`, `if`, or `|`, found `(` - --> $DIR/pat-recover-wildcards.rs:49:11 + --> $DIR/recover-pat-wildcards.rs:49:11 | LL | ..(_) => () | ^ expected one of `=>`, `if`, or `|` error: expected a pattern range bound, found an expression - --> $DIR/pat-recover-wildcards.rs:55:14 + --> $DIR/recover-pat-wildcards.rs:55:14 | LL | 4..=(2 + _) => () | ^^^^^ arbitrary expressions are not allowed in patterns error: range pattern bounds cannot have parentheses - --> $DIR/pat-recover-wildcards.rs:55:13 + --> $DIR/recover-pat-wildcards.rs:55:13 | LL | 4..=(2 + _) => () | ^ ^ |