Handle methodcalls & operators in patterns

compiler/rustc_parse/messages.ftl

@@ -766,12 +766,21 @@ parse_unexpected_const_param_declaration = unexpected `const` parameter declarat
 parse_unexpected_default_value_for_lifetime_in_generic_parameters = unexpected default lifetime parameter
  .label = lifetime parameters cannot have default values
 
+parse_unexpected_expr_in_pat = expected pattern, found expression
+ .label = expressions are not allowed in patterns
+
 parse_unexpected_if_with_if = unexpected `if` in the condition expression
  .suggestion = remove the `if`
 
 parse_unexpected_lifetime_in_pattern = unexpected lifetime `{$symbol}` in pattern
  .suggestion = remove the lifetime
 
+parse_unexpected_methodcall_in_pat = expected pattern, found method call
+ .label = method calls are not allowed in patterns
+
+parse_unexpected_paren_in_range_pat = range pattern bounds cannot have parentheses
+parse_unexpected_paren_in_range_pat_sugg = remove these parentheses
+
 parse_unexpected_parentheses_in_for_head = unexpected parentheses surrounding `for` loop head
  .suggestion = remove parentheses in `for` loop
 

compiler/rustc_parse/src/errors.rs

@@ -2372,6 +2372,43 @@ pub(crate) struct ExpectedCommaAfterPatternField {
  pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_unexpected_methodcall_in_pat)]
+pub(crate) struct MethodCallInPattern {
+ #[primary_span]
+ #[label]
+ pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(parse_unexpected_expr_in_pat)]
+pub(crate) struct ExpressionInPattern {
+ #[primary_span]
+ #[label]
+ pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(parse_unexpected_paren_in_range_pat)]
+pub(crate) struct ParenInRangePat {
+ #[primary_span]
+ pub span: Span,
+ #[subdiagnostic]
+ pub sugg: ParenInRangePatSugg,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+ parse_unexpected_paren_in_range_pat_sugg,
+ applicability = "machine-applicable"
+)]
+pub(crate) struct ParenInRangePatSugg {
+ #[suggestion_part(code = "")]
+ pub open_span: Span,
+ #[suggestion_part(code = "")]
+ pub close_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_return_types_use_thin_arrow)]
 pub(crate) struct ReturnTypesUseThinArrow {

compiler/rustc_parse/src/parser/expr.rs

@@ -2915,7 +2915,14 @@ impl<'a> Parser<'a> {
  let is_almost_fat_arrow = TokenKind::FatArrow
  .similar_tokens()
  .is_some_and(|similar_tokens| similar_tokens.contains(&this.token.kind));
- let mut result = if !is_fat_arrow && !is_almost_fat_arrow {
+
+ // this avoids the compiler saying that a `,` or `}` was expected even though
+ // the pattern isn't a never pattern (and thus an arm body is required)
+ let armless =
+ matches!(this.token.kind, token::Comma | token::CloseDelim(Delimiter::Brace))
+ || (!is_fat_arrow && !is_almost_fat_arrow && pat.could_be_never_pattern());
+
+ let mut result = if armless {
  // A pattern without a body, allowed for never patterns.
  arm_body = None;
  this.expect_one_of(&[token::Comma], &[token::CloseDelim(Delimiter::Brace)])