Update comments

Author: ShE3py

compiler/rustc_parse/src/parser/pat.rs

@@ -357,26 +357,23 @@ impl<'a> Parser<'a> {
             return None;
         }
 
-        // Returns `true` iff `token` is `x.y` float
+        // Returns `true` iff `token` is a `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;
-                }
-            }
+            let token::Literal(Lit { kind: LitKind::Float, symbol, suffix: None }) = token.kind else {
+                return false;
+            };
 
-            false
+            matches!(that.break_up_float(symbol, token.span), DestructuredFloat::MiddleDot(..))
         };
 
-        // Check for `.hello` or `.0`
-        let has_dot_expr = self.check_noexpect(&token::Dot)
+        // Check for `.hello` or `.0`.
+        let has_dot_expr = self.check_noexpect(&token::Dot) // `.`
             && self.look_ahead(1, |tok| {
-                tok.is_ident()
-                    || tok.is_integer_lit()
-                    // `0.0` get lexed as a float literal
-                    || is_float_literal(&self, &tok)
+                tok.is_ident() // `hello`
+                || tok.is_integer_lit() // `0`
+                || is_float_literal(&self, &tok) // `0.0`
             });
 
         // Check for operators.
@@ -388,7 +385,7 @@ impl<'a> Parser<'a> {
         let has_trailing_operator = matches!(self.token.kind, token::BinOp(op) if op != BinOpToken::Or)
             || self.token.kind == token::Question
             || (self.token.kind == token::OpenDelim(Delimiter::Bracket)
-                && self.look_ahead(1, |tok| tok.kind != token::CloseDelim(Delimiter::Bracket)))
+                && self.look_ahead(1, |tok| tok.kind != token::CloseDelim(Delimiter::Bracket))) // excludes `[]`
             || self.token.is_keyword(kw::As);
 
         if !has_dot_expr && !has_trailing_operator {
@@ -431,13 +428,15 @@ impl<'a> Parser<'a> {
 
                 let span = expr.span;
 
-                let mut diag = self.dcx().create_err(UnexpectedExpressionInPattern {
+                let mut err = self.dcx().create_err(UnexpectedExpressionInPattern {
                     span,
                     is_bound,
                     is_method_call,
                 });
+
+                // FIXME(inline_const): once stabilized, remove this check and remove the `(requires #[feature(inline_const])` note from the message
                 if self.psess.unstable_features.is_nightly_build() {
-                    diag.subdiagnostic(
+                    err.subdiagnostic(
                         &self.dcx(),
                         UnexpectedExpressionInPatternConstPatSugg {
                             start_span: span.shrink_to_lo(),
@@ -446,7 +445,7 @@ impl<'a> Parser<'a> {
                     );
                 }
 
-                return Some((diag.stash(span, StashKey::ExprInPat).unwrap(), span));
+                return Some((err.stash(span, StashKey::ExprInPat).unwrap(), span));
             }
         }