Address review comments.

Author: nnethercote

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),

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.

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

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();

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!(

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);

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

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]))
     }

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 {

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;
                 }
             }

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()
             }
         }
     }

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();

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()?

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);

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 {