Recover field accesses in patterns

Author: ShE3py

compiler/rustc_parse/src/parser/expr.rs

@@ -94,7 +94,7 @@ impl From<P<Expr>> for LhsExpr {
 }
 
 #[derive(Debug)]
-enum DestructuredFloat {
+pub(crate) enum DestructuredFloat {
     /// 1e2
     Single(Symbol, Span),
     /// 1.
@@ -1079,7 +1079,7 @@ impl<'a> Parser<'a> {
     // we should break everything including floats into more basic proc-macro style
     // tokens in the lexer (probably preferable).
     // See also `TokenKind::break_two_token_op` which does similar splitting of `>>` into `>`.
-    fn break_up_float(&self, float: Symbol, span: Span) -> DestructuredFloat {
+    pub(crate) fn break_up_float(&self, float: Symbol, span: Span) -> DestructuredFloat {
         #[derive(Debug)]
         enum FloatComponent {
             IdentLike(String),

compiler/rustc_parse/src/parser/pat.rs

@@ -10,7 +10,7 @@ use crate::errors::{
     UnexpectedParenInRangePatSugg, UnexpectedVertVertBeforeFunctionParam,
     UnexpectedVertVertInPattern,
 };
-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};
 use rustc_ast::mut_visit::{noop_visit_pat, MutVisitor};
 use rustc_ast::ptr::P;
@@ -357,14 +357,27 @@ impl<'a> Parser<'a> {
             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 `x.y` float
+        let is_float_literal = |that: &Self, token: &Token| -> bool {
+            use token::{Lit, LitKind};
+
+            if let token::Literal(Lit { kind: LitKind::Float, symbol, suffix: None }) = token.kind {
+                if let DestructuredFloat::MiddleDot(..) = that.break_up_float(symbol, token.span) {
+                    return true;
+                }
+            }
+
+            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, |tok| tok.kind == token::OpenDelim(Delimiter::Parenthesis));
+                tok.is_ident()
+                    || tok.is_integer_lit()
+                    // `0.0` get lexed as a float literal
+                    || is_float_literal(&self, &tok)
+            });
 
         // Check for operators.
         // `|` is excluded as it is used in pattern alternatives and lambdas,
@@ -376,7 +389,7 @@ impl<'a> Parser<'a> {
             || (self.token.kind == token::OpenDelim(Delimiter::Bracket)
                 && self.look_ahead(1, |tok| tok.kind != token::CloseDelim(Delimiter::Bracket)));
 
-        if !has_trailing_method && !has_trailing_operator {
+        if !has_dot_expr && !has_trailing_operator {
             // Nothing to recover here.
             return None;
         }
@@ -412,7 +425,7 @@ impl<'a> Parser<'a> {
                         && 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;
+                let is_method_call = false && non_assoc_span == expr.span;
 
                 return Some(self.dcx().emit_err(UnexpectedExpressionInPattern {
                     span: expr.span,

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:4: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:4: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:4:22
+   |
+LL |   let x.y::<isize>.z foo;
+   |                      ^^^ expected one of 9 possible tokens
+
+error: aborting due to 3 previous errors