From 2a1e2e9632af4098aea3136fc80e165284deb927 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 20 Dec 2024 07:28:16 +1100
Subject: [PATCH 1/2] Replace `ast::TokenKind::BinOp{,Eq}` and remove
`BinOpToken`.
`BinOpToken` is badly named, because it only covers the assignable
binary ops and excludes comparisons and `&&`/`||`. Its use in
`ast::TokenKind` does allow a small amount of code sharing, but it's a
clumsy factoring.
This commit removes `ast::TokenKind::BinOp{,Eq}`, replacing each one
with 10 individual variants. This makes `ast::TokenKind` more similar to
`rustc_lexer::TokenKind`, which has individual variants for all
operators.
Although the number of lines of code increases, the number of chars
decreases due to the frequent use of shorter names like `token::Plus`
instead of `token::BinOp(BinOpToken::Plus)`.
---
compiler/rustc_ast/src/token.rs | 290 ++++++++++--------
compiler/rustc_ast/src/util/parser.rs | 42 +--
compiler/rustc_ast_pretty/src/pprust/state.rs | 41 +--
compiler/rustc_expand/src/mbe/macro_rules.rs | 10 +-
compiler/rustc_expand/src/mbe/quoted.rs | 4 +-
.../rustc_expand/src/proc_macro_server.rs | 67 ++--
compiler/rustc_parse/src/lexer/mod.rs | 16 +-
.../rustc_parse/src/lexer/unicode_chars.rs | 10 +-
.../rustc_parse/src/parser/diagnostics.rs | 19 +-
compiler/rustc_parse/src/parser/expr.rs | 36 +--
compiler/rustc_parse/src/parser/item.rs | 12 +-
compiler/rustc_parse/src/parser/mod.rs | 8 +-
compiler/rustc_parse/src/parser/pat.rs | 12 +-
compiler/rustc_parse/src/parser/path.rs | 5 +-
compiler/rustc_parse/src/parser/stmt.rs | 13 +-
compiler/rustc_parse/src/parser/token_type.rs | 17 +-
compiler/rustc_parse/src/parser/ty.rs | 18 +-
src/librustdoc/clean/render_macro_matchers.rs | 11 +-
src/tools/rustfmt/src/macros.rs | 30 +-
19 files changed, 352 insertions(+), 309 deletions(-)
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
index 6cd0e15c557f4..9304636eda6ca 100644
--- a/compiler/rustc_ast/src/token.rs
+++ b/compiler/rustc_ast/src/token.rs
@@ -2,7 +2,6 @@ use std::borrow::Cow;
use std::fmt;
use std::sync::Arc;
-pub use BinOpToken::*;
pub use LitKind::*;
pub use Nonterminal::*;
pub use NtExprKind::*;
@@ -26,21 +25,6 @@ pub enum CommentKind {
Block,
}
-#[derive(Clone, PartialEq, Encodable, Decodable, Hash, Debug, Copy)]
-#[derive(HashStable_Generic)]
-pub enum BinOpToken {
- Plus,
- Minus,
- Star,
- Slash,
- Percent,
- Caret,
- And,
- Or,
- Shl,
- Shr,
-}
-
// This type must not implement `Hash` due to the unusual `PartialEq` impl below.
#[derive(Copy, Clone, Debug, Encodable, Decodable, HashStable_Generic)]
pub enum InvisibleOrigin {
@@ -379,8 +363,46 @@ pub enum TokenKind {
Not,
/// `~`
Tilde,
- BinOp(BinOpToken),
- BinOpEq(BinOpToken),
+ // `+`
+ Plus,
+ // `-`
+ Minus,
+ // `*`
+ Star,
+ // `/`
+ Slash,
+ // `%`
+ Percent,
+ // `^`
+ Caret,
+ // `&`
+ And,
+ // `|`
+ Or,
+ // `<<`
+ Shl,
+ // `>>`
+ Shr,
+ // `+=`
+ PlusEq,
+ // `-=`
+ MinusEq,
+ // `*=`
+ StarEq,
+ // `/=`
+ SlashEq,
+ // `%=`
+ PercentEq,
+ // `^=`
+ CaretEq,
+ // `&=`
+ AndEq,
+ // `|=`
+ OrEq,
+ // `<<=`
+ ShlEq,
+ // `>>=`
+ ShrEq,
/* Structural symbols */
/// `@`
@@ -502,29 +524,29 @@ impl TokenKind {
(EqEq, 1) => (Eq, Eq),
(Ne, 1) => (Not, Eq),
(Ge, 1) => (Gt, Eq),
- (AndAnd, 1) => (BinOp(And), BinOp(And)),
- (OrOr, 1) => (BinOp(Or), BinOp(Or)),
- (BinOp(Shl), 1) => (Lt, Lt),
- (BinOp(Shr), 1) => (Gt, Gt),
- (BinOpEq(Plus), 1) => (BinOp(Plus), Eq),
- (BinOpEq(Minus), 1) => (BinOp(Minus), Eq),
- (BinOpEq(Star), 1) => (BinOp(Star), Eq),
- (BinOpEq(Slash), 1) => (BinOp(Slash), Eq),
- (BinOpEq(Percent), 1) => (BinOp(Percent), Eq),
- (BinOpEq(Caret), 1) => (BinOp(Caret), Eq),
- (BinOpEq(And), 1) => (BinOp(And), Eq),
- (BinOpEq(Or), 1) => (BinOp(Or), Eq),
- (BinOpEq(Shl), 1) => (Lt, Le), // `<` + `<=`
- (BinOpEq(Shl), 2) => (BinOp(Shl), Eq), // `<<` + `=`
- (BinOpEq(Shr), 1) => (Gt, Ge), // `>` + `>=`
- (BinOpEq(Shr), 2) => (BinOp(Shr), Eq), // `>>` + `=`
+ (AndAnd, 1) => (And, And),
+ (OrOr, 1) => (Or, Or),
+ (Shl, 1) => (Lt, Lt),
+ (Shr, 1) => (Gt, Gt),
+ (PlusEq, 1) => (Plus, Eq),
+ (MinusEq, 1) => (Minus, Eq),
+ (StarEq, 1) => (Star, Eq),
+ (SlashEq, 1) => (Slash, Eq),
+ (PercentEq, 1) => (Percent, Eq),
+ (CaretEq, 1) => (Caret, Eq),
+ (AndEq, 1) => (And, Eq),
+ (OrEq, 1) => (Or, Eq),
+ (ShlEq, 1) => (Lt, Le), // `<` + `<=`
+ (ShlEq, 2) => (Shl, Eq), // `<<` + `=`
+ (ShrEq, 1) => (Gt, Ge), // `>` + `>=`
+ (ShrEq, 2) => (Shr, Eq), // `>>` + `=`
(DotDot, 1) => (Dot, Dot),
(DotDotDot, 1) => (Dot, DotDot), // `.` + `..`
(DotDotDot, 2) => (DotDot, Dot), // `..` + `.`
(DotDotEq, 2) => (DotDot, Eq),
(PathSep, 1) => (Colon, Colon),
- (RArrow, 1) => (BinOp(Minus), Gt),
- (LArrow, 1) => (Lt, BinOp(Minus)),
+ (RArrow, 1) => (Minus, Gt),
+ (LArrow, 1) => (Lt, Minus),
(FatArrow, 1) => (Eq, Gt),
_ => return None,
})
@@ -543,7 +565,7 @@ impl TokenKind {
}
pub fn should_end_const_arg(&self) -> bool {
- matches!(self, Gt | Ge | BinOp(Shr) | BinOpEq(Shr))
+ matches!(self, Gt | Ge | Shr | ShrEq)
}
}
@@ -582,11 +604,11 @@ impl Token {
pub fn is_punct(&self) -> bool {
match self.kind {
- Eq | Lt | Le | EqEq | Ne | Ge | Gt | AndAnd | OrOr | Not | Tilde | BinOp(_)
- | BinOpEq(_) | At | Dot | DotDot | DotDotDot | DotDotEq | Comma | Semi | Colon
- | PathSep | RArrow | LArrow | FatArrow | Pound | Dollar | Question | SingleQuote => {
- true
- }
+ Eq | Lt | Le | EqEq | Ne | Ge | Gt | AndAnd | OrOr | Not | Tilde | Plus | Minus
+ | Star | Slash | Percent | Caret | And | Or | Shl | Shr | PlusEq | MinusEq | StarEq
+ | SlashEq | PercentEq | CaretEq | AndEq | OrEq | ShlEq | ShrEq | At | Dot | DotDot
+ | DotDotDot | DotDotEq | Comma | Semi | Colon | PathSep | RArrow | LArrow
+ | FatArrow | Pound | Dollar | Question | SingleQuote => true,
OpenDelim(..) | CloseDelim(..) | Literal(..) | DocComment(..) | Ident(..)
| NtIdent(..) | Lifetime(..) | NtLifetime(..) | Interpolated(..) | Eof => false,
@@ -594,7 +616,7 @@ impl Token {
}
pub fn is_like_plus(&self) -> bool {
- matches!(self.kind, BinOp(Plus) | BinOpEq(Plus))
+ matches!(self.kind, Plus | PlusEq)
}
/// Returns `true` if the token can appear at the start of an expression.
@@ -609,14 +631,14 @@ impl Token {
OpenDelim(Parenthesis | Brace | Bracket) | // tuple, array or block
Literal(..) | // literal
Not | // operator not
- BinOp(Minus) | // unary minus
- BinOp(Star) | // dereference
- BinOp(Or) | OrOr | // closure
- BinOp(And) | // reference
+ Minus | // unary minus
+ Star | // dereference
+ Or | OrOr | // closure
+ And | // reference
AndAnd | // double reference
// DotDotDot is no longer supported, but we need some way to display the error
DotDot | DotDotDot | DotDotEq | // range notation
- Lt | BinOp(Shl) | // associated path
+ Lt | Shl | // associated path
PathSep | // global path
Lifetime(..) | // labeled loop
Pound => true, // expression attributes
@@ -645,17 +667,16 @@ impl Token {
Ident(..) | NtIdent(..) |
OpenDelim(Delimiter::Parenthesis) | // tuple pattern
OpenDelim(Delimiter::Bracket) | // slice pattern
- BinOp(And) | // reference
- BinOp(Minus) | // negative literal
- AndAnd | // double reference
- Literal(_) | // literal
- DotDot | // range pattern (future compat)
- DotDotDot | // range pattern (future compat)
- PathSep | // path
- Lt | // path (UFCS constant)
- BinOp(Shl) => true, // path (double UFCS)
- // leading vert `|` or-pattern
- BinOp(Or) => matches!(pat_kind, PatWithOr),
+ And | // reference
+ Minus | // negative literal
+ AndAnd | // double reference
+ Literal(_) | // literal
+ DotDot | // range pattern (future compat)
+ DotDotDot | // range pattern (future compat)
+ PathSep | // path
+ Lt | // path (UFCS constant)
+ Shl => true, // path (double UFCS)
+ Or => matches!(pat_kind, PatWithOr), // leading vert `|` or-pattern
Interpolated(nt) =>
matches!(&**nt,
| NtExpr(..)
@@ -676,18 +697,18 @@ impl Token {
/// Returns `true` if the token can appear at the start of a type.
pub fn can_begin_type(&self) -> bool {
match self.uninterpolate().kind {
- Ident(name, is_raw) =>
+ Ident(name, is_raw) =>
ident_can_begin_type(name, self.span, is_raw), // type name or keyword
OpenDelim(Delimiter::Parenthesis) | // tuple
OpenDelim(Delimiter::Bracket) | // array
- Not | // never
- BinOp(Star) | // raw pointer
- BinOp(And) | // reference
- AndAnd | // double reference
- Question | // maybe bound in trait object
- Lifetime(..) | // lifetime bound in trait object
- Lt | BinOp(Shl) | // associated path
- PathSep => true, // global path
+ Not | // never
+ Star | // raw pointer
+ And | // reference
+ AndAnd | // double reference
+ Question | // maybe bound in trait object
+ Lifetime(..) | // lifetime bound in trait object
+ Lt | Shl | // associated path
+ PathSep => true, // global path
OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
MetaVarKind::Ty { .. } |
MetaVarKind::Path
@@ -701,7 +722,7 @@ impl Token {
/// Returns `true` if the token can appear at the start of a const param.
pub fn can_begin_const_arg(&self) -> bool {
match self.kind {
- OpenDelim(Delimiter::Brace) | Literal(..) | BinOp(Minus) => true,
+ OpenDelim(Delimiter::Brace) | Literal(..) | Minus => true,
Ident(name, IdentIsRaw::No) if name.is_bool_lit() => true,
Interpolated(ref nt) => matches!(&**nt, NtExpr(..) | NtBlock(..) | NtLiteral(..)),
OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
@@ -750,7 +771,7 @@ impl Token {
/// Keep this in sync with and `Lit::from_token`, excluding unary negation.
pub fn can_begin_literal_maybe_minus(&self) -> bool {
match self.uninterpolate().kind {
- Literal(..) | BinOp(Minus) => true,
+ Literal(..) | Minus => true,
Ident(name, IdentIsRaw::No) if name.is_bool_lit() => true,
Interpolated(ref nt) => match &**nt {
NtLiteral(_) => true,
@@ -875,7 +896,7 @@ impl Token {
}
pub fn is_qpath_start(&self) -> bool {
- self == &Lt || self == &BinOp(Shl)
+ self == &Lt || self == &Shl
}
pub fn is_path_start(&self) -> bool {
@@ -967,59 +988,82 @@ impl Token {
}
pub fn glue(&self, joint: &Token) -> Option<Token> {
- let kind = match self.kind {
- Eq => match joint.kind {
- Eq => EqEq,
- Gt => FatArrow,
- _ => return None,
- },
- Lt => match joint.kind {
- Eq => Le,
- Lt => BinOp(Shl),
- Le => BinOpEq(Shl),
- BinOp(Minus) => LArrow,
- _ => return None,
- },
- Gt => match joint.kind {
- Eq => Ge,
- Gt => BinOp(Shr),
- Ge => BinOpEq(Shr),
- _ => return None,
- },
- Not => match joint.kind {
- Eq => Ne,
- _ => return None,
- },
- BinOp(op) => match joint.kind {
- Eq => BinOpEq(op),
- BinOp(And) if op == And => AndAnd,
- BinOp(Or) if op == Or => OrOr,
- Gt if op == Minus => RArrow,
- _ => return None,
- },
- Dot => match joint.kind {
- Dot => DotDot,
- DotDot => DotDotDot,
- _ => return None,
- },
- DotDot => match joint.kind {
- Dot => DotDotDot,
- Eq => DotDotEq,
- _ => return None,
- },
- Colon => match joint.kind {
- Colon => PathSep,
- _ => return None,
- },
- SingleQuote => match joint.kind {
- Ident(name, is_raw) => Lifetime(Symbol::intern(&format!("'{name}")), is_raw),
- _ => return None,
- },
+ let kind = match (&self.kind, &joint.kind) {
+ (Eq, Eq) => EqEq,
+ (Eq, Gt) => FatArrow,
+ (Eq, _) => return None,
+
+ (Lt, Eq) => Le,
+ (Lt, Lt) => Shl,
+ (Lt, Le) => ShlEq,
+ (Lt, Minus) => LArrow,
+ (Lt, _) => return None,
+
+ (Gt, Eq) => Ge,
+ (Gt, Gt) => Shr,
+ (Gt, Ge) => ShrEq,
+ (Gt, _) => return None,
+
+ (Not, Eq) => Ne,
+ (Not, _) => return None,
+
+ (Plus, Eq) => PlusEq,
+ (Plus, _) => return None,
+
+ (Minus, Eq) => MinusEq,
+ (Minus, Gt) => RArrow,
+ (Minus, _) => return None,
- Le | EqEq | Ne | Ge | AndAnd | OrOr | Tilde | BinOpEq(..) | At | DotDotDot
- | DotDotEq | Comma | Semi | PathSep | RArrow | LArrow | FatArrow | Pound | Dollar
- | Question | OpenDelim(..) | CloseDelim(..) | Literal(..) | Ident(..) | NtIdent(..)
- | Lifetime(..) | NtLifetime(..) | Interpolated(..) | DocComment(..) | Eof => {
+ (Star, Eq) => StarEq,
+ (Star, _) => return None,
+
+ (Slash, Eq) => SlashEq,
+ (Slash, _) => return None,
+
+ (Percent, Eq) => PercentEq,
+ (Percent, _) => return None,
+
+ (Caret, Eq) => CaretEq,
+ (Caret, _) => return None,
+
+ (And, Eq) => AndEq,
+ (And, And) => AndAnd,
+ (And, _) => return None,
+
+ (Or, Eq) => OrEq,
+ (Or, Or) => OrOr,
+ (Or, _) => return None,
+
+ (Shl, Eq) => ShlEq,
+ (Shl, _) => return None,
+
+ (Shr, Eq) => ShrEq,
+ (Shr, _) => return None,
+
+ (Dot, Dot) => DotDot,
+ (Dot, DotDot) => DotDotDot,
+ (Dot, _) => return None,
+
+ (DotDot, Dot) => DotDotDot,
+ (DotDot, Eq) => DotDotEq,
+ (DotDot, _) => return None,
+
+ (Colon, Colon) => PathSep,
+ (Colon, _) => return None,
+
+ (SingleQuote, Ident(name, is_raw)) => {
+ Lifetime(Symbol::intern(&format!("'{name}")), *is_raw)
+ }
+ (SingleQuote, _) => return None,
+
+ (
+ Le | EqEq | Ne | Ge | AndAnd | OrOr | Tilde | PlusEq | MinusEq | StarEq | SlashEq
+ | PercentEq | CaretEq | AndEq | OrEq | ShlEq | ShrEq | At | DotDotDot | DotDotEq
+ | Comma | Semi | PathSep | RArrow | LArrow | FatArrow | Pound | Dollar | Question
+ | OpenDelim(..) | CloseDelim(..) | Literal(..) | Ident(..) | NtIdent(..)
+ | Lifetime(..) | NtLifetime(..) | Interpolated(..) | DocComment(..) | Eof,
+ _,
+ ) => {
return None;
}
};
diff --git a/compiler/rustc_ast/src/util/parser.rs b/compiler/rustc_ast/src/util/parser.rs
index 69454967eed62..98b1fc52ed747 100644
--- a/compiler/rustc_ast/src/util/parser.rs
+++ b/compiler/rustc_ast/src/util/parser.rs
@@ -1,7 +1,7 @@
use rustc_span::kw;
use crate::ast::{self, BinOpKind, RangeLimits};
-use crate::token::{self, BinOpToken, Token};
+use crate::token::{self, Token};
/// Associative operator.
#[derive(Copy, Clone, PartialEq, Debug)]
@@ -34,26 +34,26 @@ impl AssocOp {
use AssocOp::*;
match t.kind {
token::Eq => Some(Assign),
- token::BinOp(BinOpToken::Plus) => Some(Binary(BinOpKind::Add)),
- token::BinOp(BinOpToken::Minus) => Some(Binary(BinOpKind::Sub)),
- token::BinOp(BinOpToken::Star) => Some(Binary(BinOpKind::Mul)),
- token::BinOp(BinOpToken::Slash) => Some(Binary(BinOpKind::Div)),
- token::BinOp(BinOpToken::Percent) => Some(Binary(BinOpKind::Rem)),
- token::BinOp(BinOpToken::Caret) => Some(Binary(BinOpKind::BitXor)),
- token::BinOp(BinOpToken::And) => Some(Binary(BinOpKind::BitAnd)),
- token::BinOp(BinOpToken::Or) => Some(Binary(BinOpKind::BitOr)),
- token::BinOp(BinOpToken::Shl) => Some(Binary(BinOpKind::Shl)),
- token::BinOp(BinOpToken::Shr) => Some(Binary(BinOpKind::Shr)),
- token::BinOpEq(BinOpToken::Plus) => Some(AssignOp(BinOpKind::Add)),
- token::BinOpEq(BinOpToken::Minus) => Some(AssignOp(BinOpKind::Sub)),
- token::BinOpEq(BinOpToken::Star) => Some(AssignOp(BinOpKind::Mul)),
- token::BinOpEq(BinOpToken::Slash) => Some(AssignOp(BinOpKind::Div)),
- token::BinOpEq(BinOpToken::Percent) => Some(AssignOp(BinOpKind::Rem)),
- token::BinOpEq(BinOpToken::Caret) => Some(AssignOp(BinOpKind::BitXor)),
- token::BinOpEq(BinOpToken::And) => Some(AssignOp(BinOpKind::BitAnd)),
- token::BinOpEq(BinOpToken::Or) => Some(AssignOp(BinOpKind::BitOr)),
- token::BinOpEq(BinOpToken::Shl) => Some(AssignOp(BinOpKind::Shl)),
- token::BinOpEq(BinOpToken::Shr) => Some(AssignOp(BinOpKind::Shr)),
+ token::Plus => Some(Binary(BinOpKind::Add)),
+ token::Minus => Some(Binary(BinOpKind::Sub)),
+ token::Star => Some(Binary(BinOpKind::Mul)),
+ token::Slash => Some(Binary(BinOpKind::Div)),
+ token::Percent => Some(Binary(BinOpKind::Rem)),
+ token::Caret => Some(Binary(BinOpKind::BitXor)),
+ token::And => Some(Binary(BinOpKind::BitAnd)),
+ token::Or => Some(Binary(BinOpKind::BitOr)),
+ token::Shl => Some(Binary(BinOpKind::Shl)),
+ token::Shr => Some(Binary(BinOpKind::Shr)),
+ token::PlusEq => Some(AssignOp(BinOpKind::Add)),
+ token::MinusEq => Some(AssignOp(BinOpKind::Sub)),
+ token::StarEq => Some(AssignOp(BinOpKind::Mul)),
+ token::SlashEq => Some(AssignOp(BinOpKind::Div)),
+ token::PercentEq => Some(AssignOp(BinOpKind::Rem)),
+ token::CaretEq => Some(AssignOp(BinOpKind::BitXor)),
+ token::AndEq => Some(AssignOp(BinOpKind::BitAnd)),
+ token::OrEq => Some(AssignOp(BinOpKind::BitOr)),
+ token::ShlEq => Some(AssignOp(BinOpKind::Shl)),
+ token::ShrEq => Some(AssignOp(BinOpKind::Shr)),
token::Lt => Some(Binary(BinOpKind::Lt)),
token::Le => Some(Binary(BinOpKind::Le)),
token::Ge => Some(Binary(BinOpKind::Ge)),
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 44e956dc37f3e..9d922b61567e7 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -11,9 +11,7 @@ use std::sync::Arc;
use rustc_ast::attr::AttrIdGenerator;
use rustc_ast::ptr::P;
-use rustc_ast::token::{
- self, BinOpToken, CommentKind, Delimiter, IdentIsRaw, Nonterminal, Token, TokenKind,
-};
+use rustc_ast::token::{self, CommentKind, Delimiter, IdentIsRaw, Nonterminal, Token, TokenKind};
use rustc_ast::tokenstream::{Spacing, TokenStream, TokenTree};
use rustc_ast::util::classify;
use rustc_ast::util::comments::{Comment, CommentStyle};
@@ -344,21 +342,6 @@ fn space_between(tt1: &TokenTree, tt2: &TokenTree) -> bool {
}
}
-fn binop_to_string(op: BinOpToken) -> &'static str {
- match op {
- token::Plus => "+",
- token::Minus => "-",
- token::Star => "*",
- token::Slash => "/",
- token::Percent => "%",
- token::Caret => "^",
- token::And => "&",
- token::Or => "|",
- token::Shl => "<<",
- token::Shr => ">>",
- }
-}
-
pub fn doc_comment_to_string(
comment_kind: CommentKind,
attr_style: ast::AttrStyle,
@@ -917,8 +900,26 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
token::Tilde => "~".into(),
token::OrOr => "||".into(),
token::AndAnd => "&&".into(),
- token::BinOp(op) => binop_to_string(op).into(),
- token::BinOpEq(op) => format!("{}=", binop_to_string(op)).into(),
+ token::Plus => "+".into(),
+ token::Minus => "-".into(),
+ token::Star => "*".into(),
+ token::Slash => "/".into(),
+ token::Percent => "%".into(),
+ token::Caret => "^".into(),
+ token::And => "&".into(),
+ token::Or => "|".into(),
+ token::Shl => "<<".into(),
+ token::Shr => ">>".into(),
+ token::PlusEq => "+=".into(),
+ token::MinusEq => "-=".into(),
+ token::StarEq => "*=".into(),
+ token::SlashEq => "/=".into(),
+ token::PercentEq => "%=".into(),
+ token::CaretEq => "^=".into(),
+ token::AndEq => "&=".into(),
+ token::OrEq => "|=".into(),
+ token::ShlEq => "<<=".into(),
+ token::ShrEq => ">>=".into(),
/* Structural symbols */
token::At => "@".into(),
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index cc7e3e651050a..db45739e2ddec 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -1135,7 +1135,7 @@ fn check_matcher_core<'tt>(
&& matches!(kind, NonterminalKind::Pat(PatParam { inferred: true }))
&& matches!(
next_token,
- TokenTree::Token(token) if *token == BinOp(token::BinOpToken::Or)
+ TokenTree::Token(token) if *token == token::Or
)
{
// It is suggestion to use pat_param, for example: $x:pat -> $x:pat_param.
@@ -1177,7 +1177,7 @@ fn check_matcher_core<'tt>(
if kind == NonterminalKind::Pat(PatWithOr)
&& sess.psess.edition.at_least_rust_2021()
- && next_token.is_token(&BinOp(token::BinOpToken::Or))
+ && next_token.is_token(&token::Or)
{
let suggestion = quoted_tt_to_string(&TokenTree::MetaVarDecl(
span,
@@ -1296,7 +1296,7 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
const TOKENS: &[&str] = &["`=>`", "`,`", "`=`", "`|`", "`if`", "`in`"];
match tok {
TokenTree::Token(token) => match token.kind {
- FatArrow | Comma | Eq | BinOp(token::Or) => IsInFollow::Yes,
+ FatArrow | Comma | Eq | Or => IsInFollow::Yes,
Ident(name, IdentIsRaw::No) if name == kw::If || name == kw::In => {
IsInFollow::Yes
}
@@ -1332,9 +1332,9 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
| Colon
| Eq
| Gt
- | BinOp(token::Shr)
+ | Shr
| Semi
- | BinOp(token::Or) => IsInFollow::Yes,
+ | Or => IsInFollow::Yes,
Ident(name, IdentIsRaw::No) if name == kw::As || name == kw::Where => {
IsInFollow::Yes
}
diff --git a/compiler/rustc_expand/src/mbe/quoted.rs b/compiler/rustc_expand/src/mbe/quoted.rs
index b9a0615790790..8cb001391c529 100644
--- a/compiler/rustc_expand/src/mbe/quoted.rs
+++ b/compiler/rustc_expand/src/mbe/quoted.rs
@@ -302,8 +302,8 @@ fn parse_tree<'a>(
/// `None`.
fn kleene_op(token: &Token) -> Option<KleeneOp> {
match token.kind {
- token::BinOp(token::Star) => Some(KleeneOp::ZeroOrMore),
- token::BinOp(token::Plus) => Some(KleeneOp::OneOrMore),
+ token::Star => Some(KleeneOp::ZeroOrMore),
+ token::Plus => Some(KleeneOp::OneOrMore),
token::Question => Some(KleeneOp::ZeroOrOne),
_ => None,
}
diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index 5581a6e65089a..a8a323c7a8deb 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -182,26 +182,26 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)> for Vec<TokenTree<TokenStre
OrOr => op("||"),
Not => op("!"),
Tilde => op("~"),
- BinOp(Plus) => op("+"),
- BinOp(Minus) => op("-"),
- BinOp(Star) => op("*"),
- BinOp(Slash) => op("/"),
- BinOp(Percent) => op("%"),
- BinOp(Caret) => op("^"),
- BinOp(And) => op("&"),
- BinOp(Or) => op("|"),
- BinOp(Shl) => op("<<"),
- BinOp(Shr) => op(">>"),
- BinOpEq(Plus) => op("+="),
- BinOpEq(Minus) => op("-="),
- BinOpEq(Star) => op("*="),
- BinOpEq(Slash) => op("/="),
- BinOpEq(Percent) => op("%="),
- BinOpEq(Caret) => op("^="),
- BinOpEq(And) => op("&="),
- BinOpEq(Or) => op("|="),
- BinOpEq(Shl) => op("<<="),
- BinOpEq(Shr) => op(">>="),
+ Plus => op("+"),
+ Minus => op("-"),
+ Star => op("*"),
+ Slash => op("/"),
+ Percent => op("%"),
+ Caret => op("^"),
+ And => op("&"),
+ Or => op("|"),
+ Shl => op("<<"),
+ Shr => op(">>"),
+ PlusEq => op("+="),
+ MinusEq => op("-="),
+ StarEq => op("*="),
+ SlashEq => op("/="),
+ PercentEq => op("%="),
+ CaretEq => op("^="),
+ AndEq => op("&="),
+ OrEq => op("|="),
+ ShlEq => op("<<="),
+ ShrEq => op(">>="),
At => op("@"),
Dot => op("."),
DotDot => op(".."),
@@ -324,14 +324,14 @@ impl ToInternal<SmallVec<[tokenstream::TokenTree; 2]>>
b'>' => Gt,
b'!' => Not,
b'~' => Tilde,
- b'+' => BinOp(Plus),
- b'-' => BinOp(Minus),
- b'*' => BinOp(Star),
- b'/' => BinOp(Slash),
- b'%' => BinOp(Percent),
- b'^' => BinOp(Caret),
- b'&' => BinOp(And),
- b'|' => BinOp(Or),
+ b'+' => Plus,
+ b'-' => Minus,
+ b'*' => Star,
+ b'/' => Slash,
+ b'%' => Percent,
+ b'^' => Caret,
+ b'&' => And,
+ b'|' => Or,
b'@' => At,
b'.' => Dot,
b',' => Comma,
@@ -372,10 +372,9 @@ impl ToInternal<SmallVec<[tokenstream::TokenTree; 2]>>
suffix,
span,
}) if symbol.as_str().starts_with('-') => {
- let minus = BinOp(BinOpToken::Minus);
let symbol = Symbol::intern(&symbol.as_str()[1..]);
let integer = TokenKind::lit(token::Integer, symbol, suffix);
- let a = tokenstream::TokenTree::token_joint_hidden(minus, span);
+ let a = tokenstream::TokenTree::token_joint_hidden(Minus, span);
let b = tokenstream::TokenTree::token_alone(integer, span);
smallvec![a, b]
}
@@ -385,10 +384,9 @@ impl ToInternal<SmallVec<[tokenstream::TokenTree; 2]>>
suffix,
span,
}) if symbol.as_str().starts_with('-') => {
- let minus = BinOp(BinOpToken::Minus);
let symbol = Symbol::intern(&symbol.as_str()[1..]);
let float = TokenKind::lit(token::Float, symbol, suffix);
- let a = tokenstream::TokenTree::token_joint_hidden(minus, span);
+ let a = tokenstream::TokenTree::token_joint_hidden(Minus, span);
let b = tokenstream::TokenTree::token_alone(float, span);
smallvec![a, b]
}
@@ -599,10 +597,7 @@ impl server::TokenStream for Rustc<'_, '_> {
Ok(Self::TokenStream::from_iter([
// FIXME: The span of the `-` token is lost when
// parsing, so we cannot faithfully recover it here.
- tokenstream::TokenTree::token_joint_hidden(
- token::BinOp(token::Minus),
- e.span,
- ),
+ tokenstream::TokenTree::token_joint_hidden(token::Minus, e.span),
tokenstream::TokenTree::token_alone(token::Literal(*token_lit), e.span),
]))
}
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index 792e2cc26ef1c..94604043bac67 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -387,14 +387,14 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
rustc_lexer::TokenKind::Bang => token::Not,
rustc_lexer::TokenKind::Lt => token::Lt,
rustc_lexer::TokenKind::Gt => token::Gt,
- rustc_lexer::TokenKind::Minus => token::BinOp(token::Minus),
- rustc_lexer::TokenKind::And => token::BinOp(token::And),
- rustc_lexer::TokenKind::Or => token::BinOp(token::Or),
- rustc_lexer::TokenKind::Plus => token::BinOp(token::Plus),
- rustc_lexer::TokenKind::Star => token::BinOp(token::Star),
- rustc_lexer::TokenKind::Slash => token::BinOp(token::Slash),
- rustc_lexer::TokenKind::Caret => token::BinOp(token::Caret),
- rustc_lexer::TokenKind::Percent => token::BinOp(token::Percent),
+ rustc_lexer::TokenKind::Minus => token::Minus,
+ rustc_lexer::TokenKind::And => token::And,
+ rustc_lexer::TokenKind::Or => token::Or,
+ rustc_lexer::TokenKind::Plus => token::Plus,
+ rustc_lexer::TokenKind::Star => token::Star,
+ rustc_lexer::TokenKind::Slash => token::Slash,
+ rustc_lexer::TokenKind::Caret => token::Caret,
+ rustc_lexer::TokenKind::Percent => token::Percent,
rustc_lexer::TokenKind::Unknown | rustc_lexer::TokenKind::InvalidIdent => {
// Don't emit diagnostics for sequences of the same invalid token
diff --git a/compiler/rustc_parse/src/lexer/unicode_chars.rs b/compiler/rustc_parse/src/lexer/unicode_chars.rs
index 648a352efd9bd..e0d9f0faaf7da 100644
--- a/compiler/rustc_parse/src/lexer/unicode_chars.rs
+++ b/compiler/rustc_parse/src/lexer/unicode_chars.rs
@@ -308,7 +308,7 @@ pub(super) static UNICODE_ARRAY: &[(char, &str, &str)] = &[
const ASCII_ARRAY: &[(&str, &str, Option<token::TokenKind>)] = &[
(" ", "Space", None),
("_", "Underscore", Some(token::Ident(kw::Underscore, token::IdentIsRaw::No))),
- ("-", "Minus/Hyphen", Some(token::BinOp(token::Minus))),
+ ("-", "Minus/Hyphen", Some(token::Minus)),
(",", "Comma", Some(token::Comma)),
(";", "Semicolon", Some(token::Semi)),
(":", "Colon", Some(token::Colon)),
@@ -321,11 +321,11 @@ const ASCII_ARRAY: &[(&str, &str, Option<token::TokenKind>)] = &[
("]", "Right Square Bracket", Some(token::CloseDelim(Delimiter::Bracket))),
("{", "Left Curly Brace", Some(token::OpenDelim(Delimiter::Brace))),
("}", "Right Curly Brace", Some(token::CloseDelim(Delimiter::Brace))),
- ("*", "Asterisk", Some(token::BinOp(token::Star))),
- ("/", "Slash", Some(token::BinOp(token::Slash))),
+ ("*", "Asterisk", Some(token::Star)),
+ ("/", "Slash", Some(token::Slash)),
("\\", "Backslash", None),
- ("&", "Ampersand", Some(token::BinOp(token::And))),
- ("+", "Plus Sign", Some(token::BinOp(token::Plus))),
+ ("&", "Ampersand", Some(token::And)),
+ ("+", "Plus Sign", Some(token::Plus)),
("<", "Less-Than Sign", Some(token::Lt)),
("=", "Equals Sign", Some(token::Eq)),
("==", "Double Equals Sign", Some(token::EqEq)),
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 02bcb1fbf7028..660425086b4f6 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -1167,7 +1167,7 @@ impl<'a> Parser<'a> {
let mut number_of_gt = 0;
while self.look_ahead(position, |t| {
trace!("check_trailing_angle_brackets: t={:?}", t);
- if *t == token::BinOp(token::BinOpToken::Shr) {
+ if *t == token::Shr {
number_of_shr += 1;
true
} else if *t == token::Gt {
@@ -1222,7 +1222,7 @@ impl<'a> Parser<'a> {
let span = lo.to(self.prev_token.span);
// Detect trailing `>` like in `x.collect::Vec<_>>()`.
let mut trailing_span = self.prev_token.span.shrink_to_hi();
- while self.token == token::BinOp(token::Shr) || self.token == token::Gt {
+ while self.token == token::Shr || self.token == token::Gt {
trailing_span = trailing_span.to(self.token.span);
self.bump();
}
@@ -1468,8 +1468,7 @@ impl<'a> Parser<'a> {
let snapshot = self.create_snapshot_for_diagnostic();
self.bump();
// So far we have parsed `foo<bar<`, consume the rest of the type args.
- let modifiers =
- [(token::Lt, 1), (token::Gt, -1), (token::BinOp(token::Shr), -2)];
+ let modifiers = [(token::Lt, 1), (token::Gt, -1), (token::Shr, -2)];
self.consume_tts(1, &modifiers);
if !&[token::OpenDelim(Delimiter::Parenthesis), token::PathSep]
@@ -2613,8 +2612,7 @@ impl<'a> Parser<'a> {
|| self.token == TokenKind::Dot;
// This will be true when a trait object type `Foo +` or a path which was a `const fn` with
// type params has been parsed.
- let was_op =
- matches!(self.prev_token.kind, token::BinOp(token::Plus | token::Shr) | token::Gt);
+ let was_op = matches!(self.prev_token.kind, token::Plus | token::Shr | token::Gt);
if !is_op_or_dot && !was_op {
// We perform these checks and early return to avoid taking a snapshot unnecessarily.
return Err(err);
@@ -2992,8 +2990,7 @@ impl<'a> Parser<'a> {
pub(super) fn recover_vcs_conflict_marker(&mut self) {
// <<<<<<<
- let Some(start) = self.conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt)
- else {
+ let Some(start) = self.conflict_marker(&TokenKind::Shl, &TokenKind::Lt) else {
return;
};
let mut spans = Vec::with_capacity(3);
@@ -3008,15 +3005,13 @@ impl<'a> Parser<'a> {
if self.token == TokenKind::Eof {
break;
}
- if let Some(span) = self.conflict_marker(&TokenKind::OrOr, &TokenKind::BinOp(token::Or))
- {
+ if let Some(span) = self.conflict_marker(&TokenKind::OrOr, &TokenKind::Or) {
middlediff3 = Some(span);
}
if let Some(span) = self.conflict_marker(&TokenKind::EqEq, &TokenKind::Eq) {
middle = Some(span);
}
- if let Some(span) = self.conflict_marker(&TokenKind::BinOp(token::Shr), &TokenKind::Gt)
- {
+ if let Some(span) = self.conflict_marker(&TokenKind::Shr, &TokenKind::Gt) {
spans.push(span);
end = Some(span);
break;
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index ef29ac2719d9c..a991ad14bc8d7 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -239,8 +239,8 @@ impl<'a> Parser<'a> {
self.bump();
}
- if self.prev_token == token::BinOp(token::Plus)
- && self.token == token::BinOp(token::Plus)
+ if self.prev_token == token::Plus
+ && self.token == token::Plus
&& self.prev_token.span.between(self.token.span).is_empty()
{
let op_span = self.prev_token.span.to(self.token.span);
@@ -250,8 +250,8 @@ impl<'a> Parser<'a> {
continue;
}
- if self.prev_token == token::BinOp(token::Minus)
- && self.token == token::BinOp(token::Minus)
+ if self.prev_token == token::Minus
+ && self.token == token::Minus
&& self.prev_token.span.between(self.token.span).is_empty()
&& !self.look_ahead(1, |tok| tok.can_begin_expr())
{
@@ -509,19 +509,19 @@ impl<'a> Parser<'a> {
// `~expr`
token::Tilde => make_it!(this, attrs, |this, _| this.recover_tilde_expr(lo)),
// `-expr`
- token::BinOp(token::Minus) => {
+ token::Minus => {
make_it!(this, attrs, |this, _| this.parse_expr_unary(lo, UnOp::Neg))
}
// `*expr`
- token::BinOp(token::Star) => {
+ token::Star => {
make_it!(this, attrs, |this, _| this.parse_expr_unary(lo, UnOp::Deref))
}
// `&expr` and `&&expr`
- token::BinOp(token::And) | token::AndAnd => {
+ token::And | token::AndAnd => {
make_it!(this, attrs, |this, _| this.parse_expr_borrow(lo))
}
// `+lit`
- token::BinOp(token::Plus) if this.look_ahead(1, |tok| tok.is_numeric_lit()) => {
+ token::Plus if this.look_ahead(1, |tok| tok.is_numeric_lit()) => {
let mut err = errors::LeadingPlusNotSupported {
span: lo,
remove_plus: None,
@@ -541,9 +541,7 @@ impl<'a> Parser<'a> {
this.parse_expr_prefix(attrs)
}
// Recover from `++x`:
- token::BinOp(token::Plus)
- if this.look_ahead(1, |t| *t == token::BinOp(token::Plus)) =>
- {
+ token::Plus if this.look_ahead(1, |t| *t == token::Plus) => {
let starts_stmt = this.prev_token == token::Semi
|| this.prev_token == token::CloseDelim(Delimiter::Brace);
let pre_span = this.token.span.to(this.look_ahead(1, |t| t.span));
@@ -723,14 +721,12 @@ impl<'a> Parser<'a> {
suggestion,
})
}
- token::BinOp(token::Shl) => {
- self.dcx().emit_err(errors::ShiftInterpretedAsGeneric {
- shift: self.token.span,
- r#type: path,
- args: args_span,
- suggestion,
- })
- }
+ token::Shl => self.dcx().emit_err(errors::ShiftInterpretedAsGeneric {
+ shift: self.token.span,
+ r#type: path,
+ args: args_span,
+ suggestion,
+ }),
_ => {
// We can end up here even without `<` being the next token, for
// example because `parse_ty_no_plus` returns `Err` on keywords,
@@ -2595,7 +2591,7 @@ impl<'a> Parser<'a> {
missing_let: None,
comparison: None,
};
- if self.prev_token == token::BinOp(token::Or) {
+ if self.prev_token == token::Or {
// This was part of a closure, the that part of the parser recover.
return Err(self.dcx().create_err(err));
} else {
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 5765a5b5315b8..2c8fe7a63a9d2 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -1293,7 +1293,7 @@ impl<'a> Parser<'a> {
if token.is_keyword(kw::Move) {
return true;
}
- matches!(token.kind, token::BinOp(token::Or) | token::OrOr)
+ matches!(token.kind, token::Or | token::OrOr)
})
} else {
// `$qual static`
@@ -1814,7 +1814,7 @@ impl<'a> Parser<'a> {
let attrs = p.parse_outer_attributes()?;
p.collect_tokens(None, attrs, ForceCollect::No, |p, attrs| {
let mut snapshot = None;
- if p.is_vcs_conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
+ if p.is_vcs_conflict_marker(&TokenKind::Shl, &TokenKind::Lt) {
// Account for `<<<<<<<` diff markers. We can't proactively error here because
// that can be a valid type start, so we snapshot and reparse only we've
// encountered another parse error.
@@ -3011,7 +3011,7 @@ impl<'a> Parser<'a> {
// else is parsed as a normal function parameter list, so some lookahead is required.
let eself_lo = self.token.span;
let (eself, eself_ident, eself_hi) = match self.token.uninterpolate().kind {
- token::BinOp(token::And) => {
+ token::And => {
let eself = if is_isolated_self(self, 1) {
// `&self`
self.bump();
@@ -3041,12 +3041,12 @@ impl<'a> Parser<'a> {
(eself, self_ident, hi)
}
// `*self`
- token::BinOp(token::Star) if is_isolated_self(self, 1) => {
+ token::Star if is_isolated_self(self, 1) => {
self.bump();
recover_self_ptr(self)?
}
// `*mut self` and `*const self`
- token::BinOp(token::Star)
+ token::Star
if self.look_ahead(1, |t| t.is_mutability()) && is_isolated_self(self, 2) =>
{
self.bump();
@@ -3077,7 +3077,7 @@ impl<'a> Parser<'a> {
}
_ => 0,
},
- token::BinOp(token::And) | token::AndAnd => 1,
+ token::And | token::AndAnd => 1,
_ if self.token.is_keyword(kw::Mut) => 1,
_ => 0,
};
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 00282ef86799b..7dabc28c6454c 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -813,9 +813,9 @@ impl<'a> Parser<'a> {
self.is_keyword_ahead(0, &[kw::Const])
&& self.look_ahead(1, |t| match &t.kind {
// async closures do not work with const closures, so we do not parse that here.
- token::Ident(kw::Move | kw::Static, IdentIsRaw::No)
- | token::OrOr
- | token::BinOp(token::Or) => true,
+ token::Ident(kw::Move | kw::Static, IdentIsRaw::No) | token::OrOr | token::Or => {
+ true
+ }
_ => false,
})
}
@@ -1651,7 +1651,7 @@ impl<'a> Parser<'a> {
/// `::{` or `::*`
fn is_import_coupler(&mut self) -> bool {
self.check_path_sep_and_look_ahead(|t| {
- matches!(t.kind, token::OpenDelim(Delimiter::Brace) | token::BinOp(token::Star))
+ matches!(t.kind, token::OpenDelim(Delimiter::Brace) | token::Star)
})
}
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 40f2e228b24e9..04cdf8e55654a 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -3,7 +3,7 @@ use std::ops::Bound;
use rustc_ast::mut_visit::{self, MutVisitor};
use rustc_ast::ptr::P;
use rustc_ast::token::NtPatKind::*;
-use rustc_ast::token::{self, BinOpToken, Delimiter, IdentIsRaw, MetaVarKind, Token};
+use rustc_ast::token::{self, Delimiter, IdentIsRaw, MetaVarKind, Token};
use rustc_ast::util::parser::ExprPrecedence;
use rustc_ast::visit::{self, Visitor};
use rustc_ast::{
@@ -358,7 +358,7 @@ impl<'a> Parser<'a> {
)
});
match (is_end_ahead, &self.token.kind) {
- (true, token::BinOp(token::Or) | token::OrOr) => {
+ (true, token::Or | token::OrOr) => {
// A `|` or possibly `||` token shouldn't be here. Ban it.
self.dcx().emit_err(TrailingVertNotAllowed {
span: self.token.span,
@@ -432,7 +432,11 @@ impl<'a> Parser<'a> {
// `[` is included for indexing operations,
// `[]` is excluded as `a[]` isn't an expression and should be recovered as `a, []` (cf. `tests/ui/parser/pat-lt-bracket-7.rs`),
// `as` is included for type casts
- let has_trailing_operator = matches!(self.token.kind, token::BinOp(op) if op != BinOpToken::Or)
+ let has_trailing_operator = matches!(
+ self.token.kind,
+ token::Plus | token::Minus | token::Star | token::Slash | token::Percent
+ | token::Caret | token::And | token::Shl | token::Shr // excludes `Or`
+ )
|| self.token == token::Question
|| (self.token == token::OpenDelim(Delimiter::Bracket)
&& self.look_ahead(1, |t| *t != token::CloseDelim(Delimiter::Bracket))) // excludes `[]`
@@ -1255,7 +1259,7 @@ impl<'a> Parser<'a> {
|| self.look_ahead(dist, |t| {
t.is_path_start() // e.g. `MY_CONST`;
|| *t == token::Dot // e.g. `.5` for recovery;
- || matches!(t.kind, token::Literal(..) | token::BinOp(token::Minus))
+ || matches!(t.kind, token::Literal(..) | token::Minus)
|| t.is_bool_lit()
|| t.is_whole_expr()
|| t.is_lifetime() // recover `'a` instead of `'a'`
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index 8091dfa2a4a41..9c6830c36727b 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -305,10 +305,7 @@ impl<'a> Parser<'a> {
let is_args_start = |token: &Token| {
matches!(
token.kind,
- token::Lt
- | token::BinOp(token::Shl)
- | token::OpenDelim(Delimiter::Parenthesis)
- | token::LArrow
+ token::Lt | token::Shl | token::OpenDelim(Delimiter::Parenthesis) | token::LArrow
)
};
let check_args_start = |this: &mut Self| {
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index a2699b077fcff..5e4034e0f4bf4 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -442,7 +442,16 @@ impl<'a> Parser<'a> {
/// Parses the RHS of a local variable declaration (e.g., `= 14;`).
fn parse_initializer(&mut self, eq_optional: bool) -> PResult<'a, Option<P<Expr>>> {
let eq_consumed = match self.token.kind {
- token::BinOpEq(..) => {
+ token::PlusEq
+ | token::MinusEq
+ | token::StarEq
+ | token::SlashEq
+ | token::PercentEq
+ | token::CaretEq
+ | token::AndEq
+ | token::OrEq
+ | token::ShlEq
+ | token::ShrEq => {
// Recover `let x <op>= 1` as `let x = 1` We must not use `+ BytePos(1)` here
// because `<op>` can be a multi-byte lookalike that was recovered, e.g. `➖=` (the
// `➖` is a U+2796 Heavy Minus Sign Unicode Character) that was recovered as a
@@ -688,7 +697,7 @@ impl<'a> Parser<'a> {
if self.token == token::Eof {
break;
}
- if self.is_vcs_conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
+ if self.is_vcs_conflict_marker(&TokenKind::Shl, &TokenKind::Lt) {
// Account for `<<<<<<<` diff markers. We can't proactively error here because
// that can be a valid path start, so we snapshot and reparse only we've
// encountered another parse error.
diff --git a/compiler/rustc_parse/src/parser/token_type.rs b/compiler/rustc_parse/src/parser/token_type.rs
index 40631d9154d37..061b5dfba481d 100644
--- a/compiler/rustc_parse/src/parser/token_type.rs
+++ b/compiler/rustc_parse/src/parser/token_type.rs
@@ -445,12 +445,6 @@ macro_rules! exp {
token_type: $crate::parser::token_type::TokenType::$tok
}
};
- (@binop, $op:ident) => {
- $crate::parser::token_type::ExpTokenPair {
- tok: &rustc_ast::token::BinOp(rustc_ast::token::BinOpToken::$op),
- token_type: $crate::parser::token_type::TokenType::$op,
- }
- };
(@open, $delim:ident, $token_type:ident) => {
$crate::parser::token_type::ExpTokenPair {
tok: &rustc_ast::token::OpenDelim(rustc_ast::token::Delimiter::$delim),
@@ -487,6 +481,11 @@ macro_rules! exp {
(OrOr) => { exp!(@tok, OrOr) };
(Not) => { exp!(@tok, Not) };
(Tilde) => { exp!(@tok, Tilde) };
+ (Plus) => { exp!(@tok, Plus) };
+ (Minus) => { exp!(@tok, Minus) };
+ (Star) => { exp!(@tok, Star) };
+ (And) => { exp!(@tok, And) };
+ (Or) => { exp!(@tok, Or) };
(At) => { exp!(@tok, At) };
(Dot) => { exp!(@tok, Dot) };
(DotDot) => { exp!(@tok, DotDot) };
@@ -502,12 +501,6 @@ macro_rules! exp {
(Question) => { exp!(@tok, Question) };
(Eof) => { exp!(@tok, Eof) };
- (Plus) => { exp!(@binop, Plus) };
- (Minus) => { exp!(@binop, Minus) };
- (Star) => { exp!(@binop, Star) };
- (And) => { exp!(@binop, And) };
- (Or) => { exp!(@binop, Or) };
-
(OpenParen) => { exp!(@open, Parenthesis, OpenParen) };
(OpenBrace) => { exp!(@open, Brace, OpenBrace) };
(OpenBracket) => { exp!(@open, Bracket, OpenBracket) };
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 18af0a1c79aa2..02f24b65688ac 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -1,5 +1,5 @@
use rustc_ast::ptr::P;
-use rustc_ast::token::{self, BinOpToken, Delimiter, IdentIsRaw, MetaVarKind, Token, TokenKind};
+use rustc_ast::token::{self, Delimiter, IdentIsRaw, MetaVarKind, Token, TokenKind};
use rustc_ast::util::case::Case;
use rustc_ast::{
self as ast, BareFnTy, BoundAsyncness, BoundConstness, BoundPolarity, DUMMY_NODE_ID, FnRetTy,
@@ -86,7 +86,7 @@ enum AllowCVariadic {
/// Types can also be of the form `IDENT(u8, u8) -> u8`, however this assumes
/// that `IDENT` is not the ident of a fn trait.
fn can_continue_type_after_non_fn_ident(t: &Token) -> bool {
- t == &token::PathSep || t == &token::Lt || t == &token::BinOp(token::Shl)
+ t == &token::PathSep || t == &token::Lt || t == &token::Shl
}
fn can_begin_dyn_bound_in_edition_2015(t: &Token) -> bool {
@@ -399,7 +399,7 @@ impl<'a> Parser<'a> {
let mut trailing_plus = false;
let (ts, trailing) = self.parse_paren_comma_seq(|p| {
let ty = p.parse_ty()?;
- trailing_plus = p.prev_token == TokenKind::BinOp(token::Plus);
+ trailing_plus = p.prev_token == TokenKind::Plus;
Ok(ty)
})?;
@@ -735,7 +735,7 @@ impl<'a> Parser<'a> {
// Always parse bounds greedily for better error recovery.
let bounds = self.parse_generic_bounds()?;
- *impl_dyn_multi = bounds.len() > 1 || self.prev_token == TokenKind::BinOp(token::Plus);
+ *impl_dyn_multi = bounds.len() > 1 || self.prev_token == TokenKind::Plus;
Ok(TyKind::ImplTrait(ast::DUMMY_NODE_ID, bounds))
}
@@ -747,11 +747,7 @@ impl<'a> Parser<'a> {
self.expect_lt()?;
let (args, _, _) = self.parse_seq_to_before_tokens(
&[exp!(Gt)],
- &[
- &TokenKind::Ge,
- &TokenKind::BinOp(BinOpToken::Shr),
- &TokenKind::BinOpEq(BinOpToken::Shr),
- ],
+ &[&TokenKind::Ge, &TokenKind::Shr, &TokenKind::Shr],
SeqSep::trailing_allowed(exp!(Comma)),
|self_| {
if self_.check_keyword(exp!(SelfUpper)) {
@@ -781,7 +777,7 @@ impl<'a> Parser<'a> {
self.check_keyword(exp!(Dyn))
&& (self.token.uninterpolated_span().at_least_rust_2018()
|| self.look_ahead(1, |t| {
- (can_begin_dyn_bound_in_edition_2015(t) || *t == TokenKind::BinOp(token::Star))
+ (can_begin_dyn_bound_in_edition_2015(t) || *t == TokenKind::Star)
&& !can_continue_type_after_non_fn_ident(t)
}))
}
@@ -803,7 +799,7 @@ impl<'a> Parser<'a> {
// Always parse bounds greedily for better error recovery.
let bounds = self.parse_generic_bounds()?;
- *impl_dyn_multi = bounds.len() > 1 || self.prev_token == TokenKind::BinOp(token::Plus);
+ *impl_dyn_multi = bounds.len() > 1 || self.prev_token == TokenKind::Plus;
Ok(TyKind::TraitObject(bounds, syntax))
}
diff --git a/src/librustdoc/clean/render_macro_matchers.rs b/src/librustdoc/clean/render_macro_matchers.rs
index 3cc5f8d615a4e..b6b3491735856 100644
--- a/src/librustdoc/clean/render_macro_matchers.rs
+++ b/src/librustdoc/clean/render_macro_matchers.rs
@@ -1,4 +1,4 @@
-use rustc_ast::token::{self, BinOpToken, Delimiter, IdentIsRaw};
+use rustc_ast::token::{self, Delimiter, IdentIsRaw};
use rustc_ast::tokenstream::{TokenStream, TokenTree};
use rustc_ast_pretty::pprust::PrintState;
use rustc_ast_pretty::pprust::state::State as Printer;
@@ -137,14 +137,9 @@ fn print_tts(printer: &mut Printer<'_>, tts: &TokenStream) {
(Dollar, token::Ident(..)) => (false, DollarIdent),
(DollarIdent, token::Colon) => (false, DollarIdentColon),
(DollarIdentColon, token::Ident(..)) => (false, Other),
- (
- DollarParen,
- token::BinOp(BinOpToken::Plus | BinOpToken::Star) | token::Question,
- ) => (false, Other),
+ (DollarParen, token::Plus | token::Star | token::Question) => (false, Other),
(DollarParen, _) => (false, DollarParenSep),
- (DollarParenSep, token::BinOp(BinOpToken::Plus | BinOpToken::Star)) => {
- (false, Other)
- }
+ (DollarParenSep, token::Plus | token::Star) => (false, Other),
(Pound, token::Not) => (false, PoundBang),
(_, token::Ident(symbol, IdentIsRaw::No))
if !usually_needs_space_between_keyword_and_open_delim(*symbol, tt.span) =>
diff --git a/src/tools/rustfmt/src/macros.rs b/src/tools/rustfmt/src/macros.rs
index ea8ca38cb7725..7775db2db6bb0 100644
--- a/src/tools/rustfmt/src/macros.rs
+++ b/src/tools/rustfmt/src/macros.rs
@@ -12,7 +12,7 @@
use std::collections::HashMap;
use std::panic::{AssertUnwindSafe, catch_unwind};
-use rustc_ast::token::{BinOpToken, Delimiter, Token, TokenKind};
+use rustc_ast::token::{Delimiter, Token, TokenKind};
use rustc_ast::tokenstream::{TokenStream, TokenStreamIter, TokenTree};
use rustc_ast::{ast, ptr};
use rustc_ast_pretty::pprust;
@@ -841,7 +841,7 @@ impl MacroArgParser {
match tok {
TokenTree::Token(
Token {
- kind: TokenKind::BinOp(BinOpToken::Plus),
+ kind: TokenKind::Plus,
..
},
_,
@@ -855,7 +855,7 @@ impl MacroArgParser {
)
| TokenTree::Token(
Token {
- kind: TokenKind::BinOp(BinOpToken::Star),
+ kind: TokenKind::Star,
..
},
_,
@@ -1090,12 +1090,30 @@ fn force_space_before(tok: &TokenKind) -> bool {
| TokenKind::OrOr
| TokenKind::Not
| TokenKind::Tilde
- | TokenKind::BinOpEq(_)
+ | TokenKind::PlusEq
+ | TokenKind::MinusEq
+ | TokenKind::StarEq
+ | TokenKind::SlashEq
+ | TokenKind::PercentEq
+ | TokenKind::CaretEq
+ | TokenKind::AndEq
+ | TokenKind::OrEq
+ | TokenKind::ShlEq
+ | TokenKind::ShrEq
| TokenKind::At
| TokenKind::RArrow
| TokenKind::LArrow
| TokenKind::FatArrow
- | TokenKind::BinOp(_)
+ | TokenKind::Plus
+ | TokenKind::Minus
+ | TokenKind::Star
+ | TokenKind::Slash
+ | TokenKind::Percent
+ | TokenKind::Caret
+ | TokenKind::And
+ | TokenKind::Or
+ | TokenKind::Shl
+ | TokenKind::Shr
| TokenKind::Pound
| TokenKind::Dollar => true,
_ => false,
@@ -1114,7 +1132,7 @@ fn next_space(tok: &TokenKind) -> SpaceState {
match tok {
TokenKind::Not
- | TokenKind::BinOp(BinOpToken::And)
+ | TokenKind::And
| TokenKind::Tilde
| TokenKind::At
| TokenKind::Comma
From 53167c0b7f8112a492b9442058a034605a120c9e Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 20 Dec 2024 14:04:25 +1100
Subject: [PATCH 2/2] Rename `ast::TokenKind::Not` as `ast::TokenKind::Bang`.
For consistency with `rustc_lexer::TokenKind::Bang`, and because other
`ast::TokenKind` variants generally have syntactic names instead of
semantic names (e.g. `Star` and `DotDot` instead of `Mul` and `Range`).
---
compiler/rustc_ast/src/token.rs | 14 +++++++-------
compiler/rustc_ast/src/tokenstream.rs | 2 +-
compiler/rustc_ast_pretty/src/pprust/state.rs | 4 ++--
compiler/rustc_expand/src/config.rs | 2 +-
compiler/rustc_expand/src/mbe/macro_check.rs | 2 +-
compiler/rustc_expand/src/mbe/macro_rules.rs | 2 +-
compiler/rustc_expand/src/proc_macro_server.rs | 4 ++--
compiler/rustc_parse/src/lexer/mod.rs | 2 +-
compiler/rustc_parse/src/lexer/unicode_chars.rs | 2 +-
compiler/rustc_parse/src/parser/attr.rs | 4 ++--
compiler/rustc_parse/src/parser/diagnostics.rs | 6 +++---
compiler/rustc_parse/src/parser/expr.rs | 4 ++--
compiler/rustc_parse/src/parser/item.rs | 16 ++++++++--------
compiler/rustc_parse/src/parser/pat.rs | 6 +++---
compiler/rustc_parse/src/parser/stmt.rs | 2 +-
compiler/rustc_parse/src/parser/tests.rs | 2 +-
compiler/rustc_parse/src/parser/token_type.rs | 8 ++++----
compiler/rustc_parse/src/parser/ty.rs | 8 ++++----
src/librustdoc/clean/render_macro_matchers.rs | 2 +-
src/tools/rustfmt/src/macros.rs | 4 ++--
20 files changed, 48 insertions(+), 48 deletions(-)
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
index 9304636eda6ca..ff1edad725a46 100644
--- a/compiler/rustc_ast/src/token.rs
+++ b/compiler/rustc_ast/src/token.rs
@@ -360,7 +360,7 @@ pub enum TokenKind {
/// `||`
OrOr,
/// `!`
- Not,
+ Bang,
/// `~`
Tilde,
// `+`
@@ -522,7 +522,7 @@ impl TokenKind {
Some(match (self, n) {
(Le, 1) => (Lt, Eq),
(EqEq, 1) => (Eq, Eq),
- (Ne, 1) => (Not, Eq),
+ (Ne, 1) => (Bang, Eq),
(Ge, 1) => (Gt, Eq),
(AndAnd, 1) => (And, And),
(OrOr, 1) => (Or, Or),
@@ -604,7 +604,7 @@ impl Token {
pub fn is_punct(&self) -> bool {
match self.kind {
- Eq | Lt | Le | EqEq | Ne | Ge | Gt | AndAnd | OrOr | Not | Tilde | Plus | Minus
+ Eq | Lt | Le | EqEq | Ne | Ge | Gt | AndAnd | OrOr | Bang | Tilde | Plus | Minus
| Star | Slash | Percent | Caret | And | Or | Shl | Shr | PlusEq | MinusEq | StarEq
| SlashEq | PercentEq | CaretEq | AndEq | OrEq | ShlEq | ShrEq | At | Dot | DotDot
| DotDotDot | DotDotEq | Comma | Semi | Colon | PathSep | RArrow | LArrow
@@ -630,7 +630,7 @@ impl Token {
ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
OpenDelim(Parenthesis | Brace | Bracket) | // tuple, array or block
Literal(..) | // literal
- Not | // operator not
+ Bang | // operator not
Minus | // unary minus
Star | // dereference
Or | OrOr | // closure
@@ -701,7 +701,7 @@ impl Token {
ident_can_begin_type(name, self.span, is_raw), // type name or keyword
OpenDelim(Delimiter::Parenthesis) | // tuple
OpenDelim(Delimiter::Bracket) | // array
- Not | // never
+ Bang | // never
Star | // raw pointer
And | // reference
AndAnd | // double reference
@@ -1004,8 +1004,8 @@ impl Token {
(Gt, Ge) => ShrEq,
(Gt, _) => return None,
- (Not, Eq) => Ne,
- (Not, _) => return None,
+ (Bang, Eq) => Ne,
+ (Bang, _) => return None,
(Plus, Eq) => PlusEq,
(Plus, _) => return None,
diff --git a/compiler/rustc_ast/src/tokenstream.rs b/compiler/rustc_ast/src/tokenstream.rs
index 49ae8cc78fc5c..b9b20cf937685 100644
--- a/compiler/rustc_ast/src/tokenstream.rs
+++ b/compiler/rustc_ast/src/tokenstream.rs
@@ -651,7 +651,7 @@ impl TokenStream {
if attr_style == AttrStyle::Inner {
vec![
TokenTree::token_joint(token::Pound, span),
- TokenTree::token_joint_hidden(token::Not, span),
+ TokenTree::token_joint_hidden(token::Bang, span),
body,
]
} else {
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 9d922b61567e7..d747237f76dbc 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -317,7 +317,7 @@ fn space_between(tt1: &TokenTree, tt2: &TokenTree) -> bool {
(tt1, Tok(Token { kind: Comma | Semi | Dot, .. }, _)) if !is_punct(tt1) => false,
// IDENT + `!`: `println!()`, but `if !x { ... }` needs a space after the `if`
- (Tok(Token { kind: Ident(sym, is_raw), span }, _), Tok(Token { kind: Not, .. }, _))
+ (Tok(Token { kind: Ident(sym, is_raw), span }, _), Tok(Token { kind: Bang, .. }, _))
if !Ident::new(*sym, *span).is_reserved() || matches!(is_raw, IdentIsRaw::Yes) =>
{
false
@@ -896,7 +896,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
token::Ne => "!=".into(),
token::Ge => ">=".into(),
token::Gt => ">".into(),
- token::Not => "!".into(),
+ token::Bang => "!".into(),
token::Tilde => "~".into(),
token::OrOr => "||".into(),
token::AndAnd => "&&".into(),
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index 83255b820178f..5570c0c38e831 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -328,7 +328,7 @@ impl<'a> StripUnconfigured<'a> {
// For inner attributes, we do the same thing for the `!` in `#![attr]`.
let mut trees = if cfg_attr.style == AttrStyle::Inner {
- let Some(TokenTree::Token(bang_token @ Token { kind: TokenKind::Not, .. }, _)) =
+ let Some(TokenTree::Token(bang_token @ Token { kind: TokenKind::Bang, .. }, _)) =
orig_trees.next()
else {
panic!("Bad tokens for attribute {cfg_attr:?}");
diff --git a/compiler/rustc_expand/src/mbe/macro_check.rs b/compiler/rustc_expand/src/mbe/macro_check.rs
index 729dec2bfbdb1..1a2db233b7a64 100644
--- a/compiler/rustc_expand/src/mbe/macro_check.rs
+++ b/compiler/rustc_expand/src/mbe/macro_check.rs
@@ -432,7 +432,7 @@ fn check_nested_occurrences(
}
(
NestedMacroState::MacroRules,
- &TokenTree::Token(Token { kind: TokenKind::Not, .. }),
+ &TokenTree::Token(Token { kind: TokenKind::Bang, .. }),
) => {
state = NestedMacroState::MacroRulesNot;
}
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index db45739e2ddec..5577c8902dae8 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -690,7 +690,7 @@ fn has_compile_error_macro(rhs: &mbe::TokenTree) -> bool {
&& let TokenKind::Ident(ident, _) = ident.kind
&& ident == sym::compile_error
&& let mbe::TokenTree::Token(bang) = bang
- && let TokenKind::Not = bang.kind
+ && let TokenKind::Bang = bang.kind
&& let mbe::TokenTree::Delimited(.., del) = args
&& !del.delim.skip()
{
diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index a8a323c7a8deb..007241437eccf 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -180,7 +180,7 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)> for Vec<TokenTree<TokenStre
Gt => op(">"),
AndAnd => op("&&"),
OrOr => op("||"),
- Not => op("!"),
+ Bang => op("!"),
Tilde => op("~"),
Plus => op("+"),
Minus => op("-"),
@@ -322,7 +322,7 @@ impl ToInternal<SmallVec<[tokenstream::TokenTree; 2]>>
b'=' => Eq,
b'<' => Lt,
b'>' => Gt,
- b'!' => Not,
+ b'!' => Bang,
b'~' => Tilde,
b'+' => Plus,
b'-' => Minus,
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index 94604043bac67..1d17290e1c706 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -384,7 +384,7 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
rustc_lexer::TokenKind::Colon => token::Colon,
rustc_lexer::TokenKind::Dollar => token::Dollar,
rustc_lexer::TokenKind::Eq => token::Eq,
- rustc_lexer::TokenKind::Bang => token::Not,
+ rustc_lexer::TokenKind::Bang => token::Bang,
rustc_lexer::TokenKind::Lt => token::Lt,
rustc_lexer::TokenKind::Gt => token::Gt,
rustc_lexer::TokenKind::Minus => token::Minus,
diff --git a/compiler/rustc_parse/src/lexer/unicode_chars.rs b/compiler/rustc_parse/src/lexer/unicode_chars.rs
index e0d9f0faaf7da..ff03b42484b41 100644
--- a/compiler/rustc_parse/src/lexer/unicode_chars.rs
+++ b/compiler/rustc_parse/src/lexer/unicode_chars.rs
@@ -312,7 +312,7 @@ const ASCII_ARRAY: &[(&str, &str, Option<token::TokenKind>)] = &[
(",", "Comma", Some(token::Comma)),
(";", "Semicolon", Some(token::Semi)),
(":", "Colon", Some(token::Colon)),
- ("!", "Exclamation Mark", Some(token::Not)),
+ ("!", "Exclamation Mark", Some(token::Bang)),
("?", "Question Mark", Some(token::Question)),
(".", "Period", Some(token::Dot)),
("(", "Left Parenthesis", Some(token::OpenDelim(Delimiter::Parenthesis))),
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index 98fdd35190d8a..066b570c23f91 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -130,7 +130,7 @@ impl<'a> Parser<'a> {
assert!(this.eat(exp!(Pound)), "parse_attribute called in non-attribute position");
let style =
- if this.eat(exp!(Not)) { ast::AttrStyle::Inner } else { ast::AttrStyle::Outer };
+ if this.eat(exp!(Bang)) { ast::AttrStyle::Inner } else { ast::AttrStyle::Outer };
this.expect(exp!(OpenBracket))?;
let item = this.parse_attr_item(ForceCollect::No)?;
@@ -312,7 +312,7 @@ impl<'a> Parser<'a> {
loop {
let start_pos = self.num_bump_calls;
// Only try to parse if it is an inner attribute (has `!`).
- let attr = if self.check(exp!(Pound)) && self.look_ahead(1, |t| t == &token::Not) {
+ let attr = if self.check(exp!(Pound)) && self.look_ahead(1, |t| t == &token::Bang) {
Some(self.parse_attribute(InnerAttrPolicy::Permitted)?)
} else if let token::DocComment(comment_kind, attr_style, data) = self.token.kind {
if attr_style == ast::AttrStyle::Inner {
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 660425086b4f6..94db43bb59f81 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -1961,7 +1961,7 @@ impl<'a> Parser<'a> {
&mut self,
await_sp: Span,
) -> PResult<'a, P<Expr>> {
- let (hi, expr, is_question) = if self.token == token::Not {
+ let (hi, expr, is_question) = if self.token == token::Bang {
// Handle `await!(<expr>)`.
self.recover_await_macro()?
} else {
@@ -1973,7 +1973,7 @@ impl<'a> Parser<'a> {
}
fn recover_await_macro(&mut self) -> PResult<'a, (Span, P<Expr>, bool)> {
- self.expect(exp!(Not))?;
+ self.expect(exp!(Bang))?;
self.expect(exp!(OpenParen))?;
let expr = self.parse_expr()?;
self.expect(exp!(CloseParen))?;
@@ -2033,7 +2033,7 @@ impl<'a> Parser<'a> {
pub(super) fn try_macro_suggestion(&mut self) -> PResult<'a, P<Expr>> {
let is_try = self.token.is_keyword(kw::Try);
- let is_questionmark = self.look_ahead(1, |t| t == &token::Not); //check for !
+ let is_questionmark = self.look_ahead(1, |t| t == &token::Bang); //check for !
let is_open = self.look_ahead(2, |t| t == &token::OpenDelim(Delimiter::Parenthesis)); //check for (
if is_try && is_questionmark && is_open {
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index a991ad14bc8d7..23b366dc2c9a0 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -505,7 +505,7 @@ impl<'a> Parser<'a> {
// Note: when adding new unary operators, don't forget to adjust TokenKind::can_begin_expr()
match this.token.uninterpolate().kind {
// `!expr`
- token::Not => make_it!(this, attrs, |this, _| this.parse_expr_unary(lo, UnOp::Not)),
+ token::Bang => make_it!(this, attrs, |this, _| this.parse_expr_unary(lo, UnOp::Not)),
// `~expr`
token::Tilde => make_it!(this, attrs, |this, _| this.recover_tilde_expr(lo)),
// `-expr`
@@ -1570,7 +1570,7 @@ impl<'a> Parser<'a> {
};
// `!`, as an operator, is prefix, so we know this isn't that.
- let (span, kind) = if self.eat(exp!(Not)) {
+ let (span, kind) = if self.eat(exp!(Bang)) {
// MACRO INVOCATION expression
if qself.is_some() {
self.dcx().emit_err(errors::MacroInvocationWithQualifiedPath(path.span));
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 2c8fe7a63a9d2..3f642a7ac1fdd 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -382,7 +382,7 @@ impl<'a> Parser<'a> {
/// Are we sure this could not possibly be a macro invocation?
fn isnt_macro_invocation(&mut self) -> bool {
- self.check_ident() && self.look_ahead(1, |t| *t != token::Not && *t != token::PathSep)
+ self.check_ident() && self.look_ahead(1, |t| *t != token::Bang && *t != token::PathSep)
}
/// Recover on encountering a struct, enum, or method definition where the user
@@ -480,7 +480,7 @@ impl<'a> Parser<'a> {
/// Parses an item macro, e.g., `item!();`.
fn parse_item_macro(&mut self, vis: &Visibility) -> PResult<'a, MacCall> {
let path = self.parse_path(PathStyle::Mod)?; // `foo::bar`
- self.expect(exp!(Not))?; // `!`
+ self.expect(exp!(Bang))?; // `!`
match self.parse_delim_args() {
// `( .. )` or `[ .. ]` (followed by `;`), or `{ .. }`.
Ok(args) => {
@@ -540,7 +540,7 @@ impl<'a> Parser<'a> {
fn parse_polarity(&mut self) -> ast::ImplPolarity {
// Disambiguate `impl !Trait for Type { ... }` and `impl ! { ... }` for the never type.
- if self.check(exp!(Not)) && self.look_ahead(1, |t| t.can_begin_type()) {
+ if self.check(exp!(Bang)) && self.look_ahead(1, |t| t.can_begin_type()) {
self.bump(); // `!`
ast::ImplPolarity::Negative(self.prev_token.span)
} else {
@@ -1579,7 +1579,7 @@ impl<'a> Parser<'a> {
}
let ident = this.parse_field_ident("enum", vlo)?;
- if this.token == token::Not {
+ if this.token == token::Bang {
if let Err(err) = this.unexpected() {
err.with_note(fluent::parse_macro_expands_to_enum_variant).emit();
}
@@ -2034,7 +2034,7 @@ impl<'a> Parser<'a> {
attrs: AttrVec,
) -> PResult<'a, FieldDef> {
let name = self.parse_field_ident(adt_ty, lo)?;
- if self.token == token::Not {
+ if self.token == token::Bang {
if let Err(mut err) = self.unexpected() {
// Encounter the macro invocation
err.subdiagnostic(MacroExpandsToAdtField { adt_ty });
@@ -2184,7 +2184,7 @@ impl<'a> Parser<'a> {
if self.check_keyword(exp!(MacroRules)) {
let macro_rules_span = self.token.span;
- if self.look_ahead(1, |t| *t == token::Not) && self.look_ahead(2, |t| t.is_ident()) {
+ if self.look_ahead(1, |t| *t == token::Bang) && self.look_ahead(2, |t| t.is_ident()) {
return IsMacroRulesItem::Yes { has_bang: true };
} else if self.look_ahead(1, |t| (t.is_ident())) {
// macro_rules foo
@@ -2209,11 +2209,11 @@ impl<'a> Parser<'a> {
self.expect_keyword(exp!(MacroRules))?; // `macro_rules`
if has_bang {
- self.expect(exp!(Not))?; // `!`
+ self.expect(exp!(Bang))?; // `!`
}
let ident = self.parse_ident()?;
- if self.eat(exp!(Not)) {
+ if self.eat(exp!(Bang)) {
// Handle macro_rules! foo!
let span = self.prev_token.span;
self.dcx().emit_err(errors::MacroNameRemoveBang { span });
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 04cdf8e55654a..ec14c5718da53 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -767,7 +767,7 @@ impl<'a> Parser<'a> {
self.recover_dotdotdot_rest_pat(lo)
} else if let Some(form) = self.parse_range_end() {
self.parse_pat_range_to(form)? // `..=X`, `...X`, or `..X`.
- } else if self.eat(exp!(Not)) {
+ } else if self.eat(exp!(Bang)) {
// Parse `!`
self.psess.gated_spans.gate(sym::never_patterns, self.prev_token.span);
PatKind::Never
@@ -823,7 +823,7 @@ impl<'a> Parser<'a> {
};
let span = lo.to(self.prev_token.span);
- if qself.is_none() && self.check(exp!(Not)) {
+ if qself.is_none() && self.check(exp!(Bang)) {
self.parse_pat_mac_invoc(path)?
} else if let Some(form) = self.parse_range_end() {
let begin = self.mk_expr(span, ExprKind::Path(qself, path));
@@ -1335,7 +1335,7 @@ impl<'a> Parser<'a> {
| token::OpenDelim(Delimiter::Brace) // A struct pattern.
| token::DotDotDot | token::DotDotEq | token::DotDot // A range pattern.
| token::PathSep // A tuple / struct variant pattern.
- | token::Not)) // A macro expanding to a pattern.
+ | token::Bang)) // A macro expanding to a pattern.
}
/// Parses `ident` or `ident @ pat`.
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 5e4034e0f4bf4..3a9dc5ce79854 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -176,7 +176,7 @@ impl<'a> Parser<'a> {
let stmt = self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
let path = this.parse_path(PathStyle::Expr)?;
- if this.eat(exp!(Not)) {
+ if this.eat(exp!(Bang)) {
let stmt_mac = this.parse_stmt_mac(lo, attrs, path)?;
return Ok((
stmt_mac,
diff --git a/compiler/rustc_parse/src/parser/tests.rs b/compiler/rustc_parse/src/parser/tests.rs
index 8b8c81a77a01a..471966d086d5f 100644
--- a/compiler/rustc_parse/src/parser/tests.rs
+++ b/compiler/rustc_parse/src/parser/tests.rs
@@ -2291,7 +2291,7 @@ fn string_to_tts_macro() {
Token { kind: token::Ident(name_macro_rules, IdentIsRaw::No), .. },
_,
),
- TokenTree::Token(Token { kind: token::Not, .. }, _),
+ TokenTree::Token(Token { kind: token::Bang, .. }, _),
TokenTree::Token(Token { kind: token::Ident(name_zip, IdentIsRaw::No), .. }, _),
TokenTree::Delimited(.., macro_delim, macro_tts),
] if name_macro_rules == &kw::MacroRules && name_zip.as_str() == "zip" => {
diff --git a/compiler/rustc_parse/src/parser/token_type.rs b/compiler/rustc_parse/src/parser/token_type.rs
index 061b5dfba481d..110546d0ba663 100644
--- a/compiler/rustc_parse/src/parser/token_type.rs
+++ b/compiler/rustc_parse/src/parser/token_type.rs
@@ -25,7 +25,7 @@ pub enum TokenType {
Gt,
AndAnd,
OrOr,
- Not,
+ Bang,
Tilde,
// BinOps
@@ -172,7 +172,7 @@ impl TokenType {
Gt,
AndAnd,
OrOr,
- Not,
+ Bang,
Tilde,
Plus,
@@ -366,7 +366,7 @@ impl TokenType {
TokenType::Gt => "`>`",
TokenType::AndAnd => "`&&`",
TokenType::OrOr => "`||`",
- TokenType::Not => "`!`",
+ TokenType::Bang => "`!`",
TokenType::Tilde => "`~`",
TokenType::Plus => "`+`",
@@ -479,7 +479,7 @@ macro_rules! exp {
(Gt) => { exp!(@tok, Gt) };
(AndAnd) => { exp!(@tok, AndAnd) };
(OrOr) => { exp!(@tok, OrOr) };
- (Not) => { exp!(@tok, Not) };
+ (Bang) => { exp!(@tok, Bang) };
(Tilde) => { exp!(@tok, Tilde) };
(Plus) => { exp!(@tok, Plus) };
(Minus) => { exp!(@tok, Minus) };
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 02f24b65688ac..b45ebae079cbc 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -260,7 +260,7 @@ impl<'a> Parser<'a> {
let mut impl_dyn_multi = false;
let kind = if self.check(exp!(OpenParen)) {
self.parse_ty_tuple_or_parens(lo, allow_plus)?
- } else if self.eat(exp!(Not)) {
+ } else if self.eat(exp!(Bang)) {
// Never type `!`
TyKind::Never
} else if self.eat(exp!(Star)) {
@@ -817,7 +817,7 @@ impl<'a> Parser<'a> {
) -> PResult<'a, TyKind> {
// Simple path
let path = self.parse_path_inner(PathStyle::Type, ty_generics)?;
- if self.eat(exp!(Not)) {
+ if self.eat(exp!(Bang)) {
// Macro invocation in type position
Ok(TyKind::MacCall(P(MacCall { path, args: self.parse_delim_args()? })))
} else if allow_plus == AllowPlus::Yes && self.check_plus() {
@@ -870,7 +870,7 @@ impl<'a> Parser<'a> {
fn can_begin_bound(&mut self) -> bool {
self.check_path()
|| self.check_lifetime()
- || self.check(exp!(Not))
+ || self.check(exp!(Bang))
|| self.check(exp!(Question))
|| self.check(exp!(Tilde))
|| self.check_keyword(exp!(For))
@@ -1021,7 +1021,7 @@ impl<'a> Parser<'a> {
let polarity = if self.eat(exp!(Question)) {
BoundPolarity::Maybe(self.prev_token.span)
- } else if self.eat(exp!(Not)) {
+ } else if self.eat(exp!(Bang)) {
self.psess.gated_spans.gate(sym::negative_bounds, self.prev_token.span);
BoundPolarity::Negative(self.prev_token.span)
} else {
diff --git a/src/librustdoc/clean/render_macro_matchers.rs b/src/librustdoc/clean/render_macro_matchers.rs
index b6b3491735856..88db853d7c38f 100644
--- a/src/librustdoc/clean/render_macro_matchers.rs
+++ b/src/librustdoc/clean/render_macro_matchers.rs
@@ -140,7 +140,7 @@ fn print_tts(printer: &mut Printer<'_>, tts: &TokenStream) {
(DollarParen, token::Plus | token::Star | token::Question) => (false, Other),
(DollarParen, _) => (false, DollarParenSep),
(DollarParenSep, token::Plus | token::Star) => (false, Other),
- (Pound, token::Not) => (false, PoundBang),
+ (Pound, token::Bang) => (false, PoundBang),
(_, token::Ident(symbol, IdentIsRaw::No))
if !usually_needs_space_between_keyword_and_open_delim(*symbol, tt.span) =>
{
diff --git a/src/tools/rustfmt/src/macros.rs b/src/tools/rustfmt/src/macros.rs
index 7775db2db6bb0..664c90b991a9b 100644
--- a/src/tools/rustfmt/src/macros.rs
+++ b/src/tools/rustfmt/src/macros.rs
@@ -1088,7 +1088,7 @@ fn force_space_before(tok: &TokenKind) -> bool {
| TokenKind::Gt
| TokenKind::AndAnd
| TokenKind::OrOr
- | TokenKind::Not
+ | TokenKind::Bang
| TokenKind::Tilde
| TokenKind::PlusEq
| TokenKind::MinusEq
@@ -1131,7 +1131,7 @@ fn next_space(tok: &TokenKind) -> SpaceState {
debug!("next_space: {:?}", tok);
match tok {
- TokenKind::Not
+ TokenKind::Bang
| TokenKind::And
| TokenKind::Tilde
| TokenKind::At