Address review comments.

nnethercote · nnethercote · commit a35c855b67e5 · 2025-04-18T08:15:12.000+10:00
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
@@ -573,10 +573,10 @@ impl TokenKind {
     }
 
     pub fn is_delim(&self) -> bool {
-        self.is_open_delim().is_some() | self.is_close_delim().is_some()
+        self.open_delim().is_some() || self.close_delim().is_some()
     }
 
-    pub fn is_open_delim(&self) -> Option<Delimiter> {
+    pub fn open_delim(&self) -> Option<Delimiter> {
         match *self {
             OpenParen => Some(Delimiter::Parenthesis),
             OpenBrace => Some(Delimiter::Brace),
@@ -586,7 +586,7 @@ impl TokenKind {
         }
     }
 
-    pub fn is_close_delim(&self) -> Option<Delimiter> {
+    pub fn close_delim(&self) -> Option<Delimiter> {
         match *self {
             CloseParen => Some(Delimiter::Parenthesis),
             CloseBrace => Some(Delimiter::Brace),
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -1300,7 +1300,7 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
     use mbe::TokenTree;
 
     if let TokenTree::Token(Token { kind, .. }) = tok
-        && kind.is_close_delim().is_some()
+        && kind.close_delim().is_some()
     {
         // closing a token tree can never be matched by any fragment;
         // iow, we always require that `(` and `)` match, etc.
diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -309,8 +309,7 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)> for Vec<TokenTree<TokenStre
                 }
 
                 OpenParen | CloseParen | OpenBrace | CloseBrace | OpenBracket | CloseBracket
-                | OpenInvisible(_) | CloseInvisible(_) => unreachable!(),
-                Eof => unreachable!(),
+                | OpenInvisible(_) | CloseInvisible(_) | Eof => unreachable!(),
             }
         }
         trees
diff --git a/compiler/rustc_parse/src/lexer/tokentrees.rs b/compiler/rustc_parse/src/lexer/tokentrees.rs
@@ -18,15 +18,15 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
 
         let mut buf = Vec::new();
         loop {
-            if let Some(delim) = self.token.kind.is_open_delim() {
+            if let Some(delim) = self.token.kind.open_delim() {
                 // Invisible delimiters cannot occur here because `TokenTreesReader` parses
                 // code directly from strings, with no macro expansion involved.
                 debug_assert!(!matches!(delim, Delimiter::Invisible(_)));
                 buf.push(match self.lex_token_tree_open_delim(delim) {
                     Ok(val) => val,
                     Err(errs) => return Err(errs),
                 })
-            } else if let Some(delim) = self.token.kind.is_close_delim() {
+            } else if let Some(delim) = self.token.kind.close_delim() {
                 // Invisible delimiters cannot occur here because `TokenTreesReader` parses
                 // code directly from strings, with no macro expansion involved.
                 debug_assert!(!matches!(delim, Delimiter::Invisible(_)));
@@ -35,7 +35,7 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
                 } else {
                     Err(vec![self.close_delim_err(delim)])
                 };
-            } else if let token::Eof = self.token.kind {
+            } else if self.token.kind == token::Eof {
                 return if is_delimited {
                     Err(vec![self.eof_err()])
                 } else {
@@ -106,7 +106,7 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
         let delim_span = DelimSpan::from_pair(pre_span, self.token.span);
         let sm = self.psess.source_map();
 
-        let close_spacing = if let Some(close_delim) = self.token.kind.is_close_delim() {
+        let close_spacing = if let Some(close_delim) = self.token.kind.close_delim() {
             if close_delim == open_delim {
                 // Correct delimiter.
                 let (open_brace, open_brace_span) = self.diag_info.open_braces.pop().unwrap();
diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -502,12 +502,12 @@ fn make_attr_token_stream(
     for flat_token in iter {
         match flat_token {
             FlatToken::Token((token @ Token { kind, span }, spacing)) => {
-                if let Some(delim) = kind.is_open_delim() {
+                if let Some(delim) = kind.open_delim() {
                     stack_rest.push(mem::replace(
                         &mut stack_top,
                         FrameData { open_delim_sp: Some((delim, span, spacing)), inner: vec![] },
                     ));
-                } else if let Some(delim) = kind.is_close_delim() {
+                } else if let Some(delim) = kind.close_delim() {
                     let frame_data = mem::replace(&mut stack_top, stack_rest.pop().unwrap());
                     let (open_delim, open_sp, open_spacing) = frame_data.open_delim_sp.unwrap();
                     assert!(
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -1033,7 +1033,7 @@ impl<'a> Parser<'a> {
     ) -> PResult<'a, P<Expr>> {
         err.span_label(lo.to(decl_hi), "while parsing the body of this closure");
         let guar = match before.kind {
-            token::OpenBrace if !matches!(token.kind, token::OpenBrace) => {
+            token::OpenBrace if token.kind != token::OpenBrace => {
                 // `{ || () }` should have been `|| { () }`
                 err.multipart_suggestion(
                     "you might have meant to open the body of the closure, instead of enclosing \
@@ -1048,7 +1048,7 @@ impl<'a> Parser<'a> {
                 self.eat_to_tokens(&[exp!(CloseBrace)]);
                 guar
             }
-            token::OpenParen if !matches!(token.kind, token::OpenBrace) => {
+            token::OpenParen if token.kind != token::OpenBrace => {
                 // We are within a function call or tuple, we can emit the error
                 // and recover.
                 self.eat_to_tokens(&[exp!(CloseParen), exp!(Comma)]);
@@ -1063,7 +1063,7 @@ impl<'a> Parser<'a> {
                 );
                 err.emit()
             }
-            _ if !matches!(token.kind, token::OpenBrace) => {
+            _ if token.kind != token::OpenBrace => {
                 // We don't have a heuristic to correctly identify where the block
                 // should be closed.
                 err.multipart_suggestion_verbose(
@@ -1462,7 +1462,7 @@ impl<'a> Parser<'a> {
                         let modifiers = [(token::Lt, 1), (token::Gt, -1), (token::Shr, -2)];
                         self.consume_tts(1, &modifiers);
 
-                        if !&[token::OpenParen, token::PathSep].contains(&self.token.kind) {
+                        if !matches!(self.token.kind, token::OpenParen | token::PathSep) {
                             // We don't have `foo< bar >(` or `foo< bar >::`, so we rewind the
                             // parser and bail out.
                             self.restore_snapshot(snapshot);
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
@@ -1202,7 +1202,7 @@ impl<'a> Parser<'a> {
                 }
             }
 
-            if self.token.kind.is_close_delim().is_some() || self.token.kind == token::Comma {
+            if self.token.kind.close_delim().is_some() || self.token.kind == token::Comma {
                 break;
             } else if trailing_dot.is_none() {
                 // This loop should only repeat if there is a trailing dot.
@@ -1680,7 +1680,7 @@ impl<'a> Parser<'a> {
             self.parse_expr_block(label, lo, BlockCheckMode::Default)
         } else if !ate_colon
             && self.may_recover()
-            && (self.token.kind.is_close_delim().is_some() || self.token.is_punct())
+            && (self.token.kind.close_delim().is_some() || self.token.is_punct())
             && could_be_unclosed_char_literal(label_.ident)
         {
             let (lit, _) =
@@ -2268,7 +2268,7 @@ impl<'a> Parser<'a> {
     }
 
     fn is_array_like_block(&mut self) -> bool {
-        matches!(self.token.kind, TokenKind::OpenBrace)
+        self.token.kind == TokenKind::OpenBrace
             && self
                 .look_ahead(1, |t| matches!(t.kind, TokenKind::Ident(..) | TokenKind::Literal(_)))
             && self.look_ahead(2, |t| t == &token::Comma)
@@ -2477,7 +2477,7 @@ impl<'a> Parser<'a> {
     fn parse_closure_block_body(&mut self, ret_span: Span) -> PResult<'a, P<Expr>> {
         if self.may_recover()
             && self.token.can_begin_expr()
-            && !matches!(self.token.kind, TokenKind::OpenBrace)
+            && self.token.kind != TokenKind::OpenBrace
             && !self.token.is_metavar_block()
         {
             let snapshot = self.create_snapshot_for_diagnostic();
@@ -2958,7 +2958,7 @@ impl<'a> Parser<'a> {
         let (pat, expr) = self.parse_for_head()?;
         // Recover from missing expression in `for` loop
         if matches!(expr.kind, ExprKind::Block(..))
-            && !matches!(self.token.kind, token::OpenBrace)
+            && self.token.kind != token::OpenBrace
             && self.may_recover()
         {
             let guar = self
diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs
@@ -547,7 +547,7 @@ impl<'a> Parser<'a> {
                         matches!(t.kind, token::Gt | token::Comma | token::Colon | token::Eq)
                         // Recovery-only branch -- this could be removed,
                         // since it only affects diagnostics currently.
-                            || matches!(t.kind, token::Question)
+                            || t.kind == token::Question
                     })
                 || self.is_keyword_ahead(start + 1, &[kw::Const]))
     }
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -401,7 +401,7 @@ impl<'a> Parser<'a> {
         let ident = if self.token.is_ident()
             && (!is_const || self.look_ahead(1, |t| *t == token::OpenParen))
             && self.look_ahead(1, |t| {
-                [token::Lt, token::OpenBrace, token::OpenParen].contains(&t.kind)
+                matches!(t.kind, token::Lt | token::OpenBrace | token::OpenParen)
             }) {
             self.parse_ident().unwrap()
         } else {
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
@@ -1476,7 +1476,7 @@ impl<'a> Parser<'a> {
 
     /// Parses a single token tree from the input.
     pub fn parse_token_tree(&mut self) -> TokenTree {
-        if self.token.kind.is_open_delim().is_some() {
+        if self.token.kind.open_delim().is_some() {
             // Clone the `TokenTree::Delimited` that we are currently
             // within. That's what we are going to return.
             let tree = self.token_cursor.stack.last().unwrap().curr().unwrap().clone();
@@ -1493,7 +1493,7 @@ impl<'a> Parser<'a> {
                 // can capture these tokens if necessary.
                 self.bump();
                 if self.token_cursor.stack.len() == target_depth {
-                    debug_assert!(self.token.kind.is_close_delim().is_some());
+                    debug_assert!(self.token.kind.close_delim().is_some());
                     break;
                 }
             }
diff --git a/compiler/rustc_parse/src/parser/nonterminal.rs b/compiler/rustc_parse/src/parser/nonterminal.rs
@@ -103,7 +103,7 @@ impl<'a> Parser<'a> {
                 _ => false,
             },
             NonterminalKind::TT | NonterminalKind::Item | NonterminalKind::Stmt => {
-                token.kind.is_close_delim().is_none()
+                token.kind.close_delim().is_none()
             }
         }
     }
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
@@ -323,7 +323,7 @@ impl<'a> Parser<'a> {
     fn eat_or_separator(&mut self, lo: Option<Span>) -> EatOrResult {
         if self.recover_trailing_vert(lo) {
             EatOrResult::TrailingVert
-        } else if matches!(self.token.kind, token::OrOr) {
+        } else if self.token.kind == token::OrOr {
             // Found `||`; Recover and pretend we parsed `|`.
             self.dcx().emit_err(UnexpectedVertVertInPattern { span: self.token.span, start: lo });
             self.bump();
@@ -364,7 +364,7 @@ impl<'a> Parser<'a> {
                     span: self.token.span,
                     start: lo,
                     token: self.token,
-                    note_double_vert: matches!(self.token.kind, token::OrOr),
+                    note_double_vert: self.token.kind == token::OrOr,
                 });
                 self.bump();
                 true
@@ -835,7 +835,7 @@ impl<'a> Parser<'a> {
             // because we never have `'a: label {}` in a pattern position anyways, but it does
             // keep us from suggesting something like `let 'a: Ty = ..` => `let 'a': Ty = ..`
             && could_be_unclosed_char_literal(lt)
-            && !self.look_ahead(1, |token| matches!(token.kind, token::Colon))
+            && !self.look_ahead(1, |token| token.kind == token::Colon)
         {
             // Recover a `'a` as a `'a'` literal
             let lt = self.expect_lifetime();
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
@@ -849,7 +849,7 @@ impl<'a> Parser<'a> {
     /// the caller.
     pub(super) fn parse_const_arg(&mut self) -> PResult<'a, AnonConst> {
         // Parse const argument.
-        let value = if let token::OpenBrace = self.token.kind {
+        let value = if self.token.kind == token::OpenBrace {
             self.parse_expr_block(None, self.token.span, BlockCheckMode::Default)?
         } else {
             self.handle_unambiguous_unbraced_const_arg()?
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
@@ -864,7 +864,7 @@ impl<'a> Parser<'a> {
             StmtKind::Expr(expr)
                 if classify::expr_requires_semi_to_be_stmt(expr)
                     && !expr.attrs.is_empty()
-                    && ![token::Eof, token::Semi, token::CloseBrace].contains(&self.token.kind) =>
+                    && !matches!(self.token.kind, token::Eof | token::Semi | token::CloseBrace) =>
             {
                 // The user has written `#[attr] expr` which is unsupported. (#106020)
                 let guar = self.attr_on_non_tail_expr(&expr);
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
@@ -355,7 +355,7 @@ impl<'a> Parser<'a> {
                 }
             }
         } else if self.check_keyword(exp!(Unsafe))
-            && self.look_ahead(1, |tok| matches!(tok.kind, token::Lt))
+            && self.look_ahead(1, |tok| tok.kind == token::Lt)
         {
             self.parse_unsafe_binder_ty()?
         } else {

Original file line number	Diff line number	Diff line change
`@@ -573,10 +573,10 @@ impl TokenKind {`
`573`	`573`	`}`
`574`	`574`
`575`	`575`	`pub fn is_delim(&self) -> bool {`
`576`		`- self.is_open_delim().is_some() \| self.is_close_delim().is_some()`
	`576`	`+ self.open_delim().is_some() \|\| self.close_delim().is_some()`
`577`	`577`	`}`
`578`	`578`
`579`		`- pub fn is_open_delim(&self) -> Option<Delimiter> {`
	`579`	`+ pub fn open_delim(&self) -> Option<Delimiter> {`
`580`	`580`	`match *self {`
`581`	`581`	`OpenParen => Some(Delimiter::Parenthesis),`
`582`	`582`	`OpenBrace => Some(Delimiter::Brace),`
`@@ -586,7 +586,7 @@ impl TokenKind {`
`586`	`586`	`}`
`587`	`587`	`}`
`588`	`588`
`589`		`- pub fn is_close_delim(&self) -> Option<Delimiter> {`
	`589`	`+ pub fn close_delim(&self) -> Option<Delimiter> {`
`590`	`590`	`match *self {`
`591`	`591`	`CloseParen => Some(Delimiter::Parenthesis),`
`592`	`592`	`CloseBrace => Some(Delimiter::Brace),`
Original file line number	Diff line number	Diff line change
`@@ -1300,7 +1300,7 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {`
`1300`	`1300`	`use mbe::TokenTree;`
`1301`	`1301`
`1302`	`1302`	`if let TokenTree::Token(Token { kind, .. }) = tok`
`1303`		`- && kind.is_close_delim().is_some()`
	`1303`	`+ && kind.close_delim().is_some()`
`1304`	`1304`	`{`
`1305`	`1305`	`// closing a token tree can never be matched by any fragment;`
`1306`	`1306`	// iow, we always require that `(` and `)` match, etc.
Original file line number	Diff line number	Diff line change
`@@ -309,8 +309,7 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)> for Vec<TokenTree<TokenStre`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`OpenParen \| CloseParen \| OpenBrace \| CloseBrace \| OpenBracket \| CloseBracket`
`312`		`- \| OpenInvisible(_) \| CloseInvisible(_) => unreachable!(),`
`313`		`- Eof => unreachable!(),`
	`312`	`+ \| OpenInvisible(_) \| CloseInvisible(_) \| Eof => unreachable!(),`
`314`	`313`	`}`
`315`	`314`	`}`
`316`	`315`	`trees`
Original file line number	Diff line number	Diff line change
`@@ -547,7 +547,7 @@ impl<'a> Parser<'a> {`
`547`	`547`	`matches!(t.kind, token::Gt \| token::Comma \| token::Colon \| token::Eq)`
`548`	`548`	`// Recovery-only branch -- this could be removed,`
`549`	`549`	`// since it only affects diagnostics currently.`
`550`		`- \|\| matches!(t.kind, token::Question)`
	`550`	`+ \|\| t.kind == token::Question`
`551`	`551`	`})`
`552`	`552`	`\|\| self.is_keyword_ahead(start + 1, &[kw::Const]))`
`553`	`553`	`}`