bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Rollup merge of #129065 - nnethercote:PartialEq-TokenKind, r=spastorino

Browse source 
Use `impl PartialEq<TokenKind> for Token` more.

This lets us compare a `Token` with a `TokenKind`. It's used a lot, but can be used even more, avoiding the need for some `.kind` uses.

r? `@spastorino`
This commit is contained in:
Matthias Krüger 2024-08-15 19:32:35 +02:00 • committed by GitHub
commit bb63d75ac1
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
16 changed files with 122 additions and 129 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_builtin_macros/src/asm.rs
View file

@ -328,7 +328,7 @@ pub fn parse_asm_args<'a>(
/// Otherwise, the suggestion will be incorrect. /// Otherwise, the suggestion will be incorrect.
fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) { fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
// Tool-only output // Tool-only output
let full_span = if p.token.kind == token::Comma { span.to(p.token.span) } else { span }; let full_span = if p.token == token::Comma { span.to(p.token.span) } else { span };
p.dcx().emit_err(errors::AsmOptAlreadyprovided { span, symbol, full_span }); p.dcx().emit_err(errors::AsmOptAlreadyprovided { span, symbol, full_span });
} }
@ -338,7 +338,7 @@ fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
/// Otherwise, the suggestion will be incorrect. /// Otherwise, the suggestion will be incorrect.
fn err_unsupported_option(p: &Parser<'_>, symbol: Symbol, span: Span) { fn err_unsupported_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
// Tool-only output // Tool-only output
let full_span = if p.token.kind == token::Comma { span.to(p.token.span) } else { span }; let full_span = if p.token == token::Comma { span.to(p.token.span) } else { span };
p.dcx().emit_err(errors::GlobalAsmUnsupportedOption { span, symbol, full_span }); p.dcx().emit_err(errors::GlobalAsmUnsupportedOption { span, symbol, full_span });
} }

2
compiler/rustc_expand/src/mbe/macro_rules.rs
View file

@ -1154,7 +1154,7 @@ fn check_matcher_core<'tt>(
&& matches!(kind, NonterminalKind::Pat(PatParam { inferred: true })) && matches!(kind, NonterminalKind::Pat(PatParam { inferred: true }))
&& matches!( && matches!(
next_token, next_token,
TokenTree::Token(token) if token.kind == BinOp(token::BinOpToken::Or) TokenTree::Token(token) if *token == BinOp(token::BinOpToken::Or)
) )
{ {
// It is suggestion to use pat_param, for example: $x:pat -> $x:pat_param. // It is suggestion to use pat_param, for example: $x:pat -> $x:pat_param.

2
compiler/rustc_lint/src/builtin.rs
View file

@ -1853,7 +1853,7 @@ impl KeywordIdents {
if !prev_dollar { if !prev_dollar {
self.check_ident_token(cx, UnderMacro(true), ident); self.check_ident_token(cx, UnderMacro(true), ident);
} }
} else if token.kind == TokenKind::Dollar { } else if *token == TokenKind::Dollar {
prev_dollar = true; prev_dollar = true;
continue; continue;
} }

2
compiler/rustc_parse/src/lexer/tokentrees.rs
View file

@ -229,7 +229,7 @@ impl<'psess, 'src> TokenTreesReader<'psess, 'src> {
} else { } else {
let this_spacing = if next_tok.is_punct() { let this_spacing = if next_tok.is_punct() {
Spacing::Joint Spacing::Joint
} else if next_tok.kind == token::Eof { } else if next_tok == token::Eof {
Spacing::Alone Spacing::Alone
} else { } else {
Spacing::JointHidden Spacing::JointHidden

6
compiler/rustc_parse/src/parser/attr.rs
View file

@ -162,7 +162,7 @@ impl<'a> Parser<'a> {
} }
loop { loop {
// skip any other attributes, we want the item // skip any other attributes, we want the item
if snapshot.token.kind == token::Pound { if snapshot.token == token::Pound {
if let Err(err) = snapshot.parse_attribute(InnerAttrPolicy::Permitted) { if let Err(err) = snapshot.parse_attribute(InnerAttrPolicy::Permitted) {
err.cancel(); err.cancel();
return Some(replacement_span); return Some(replacement_span);
@ -343,7 +343,7 @@ impl<'a> Parser<'a> {
// Presumably, the majority of the time there will only be one attr. // Presumably, the majority of the time there will only be one attr.
let mut expanded_attrs = Vec::with_capacity(1); let mut expanded_attrs = Vec::with_capacity(1);
while self.token.kind != token::Eof { while self.token != token::Eof {
let lo = self.token.span; let lo = self.token.span;
let item = self.parse_attr_item(ForceCollect::Yes)?; let item = self.parse_attr_item(ForceCollect::Yes)?;
expanded_attrs.push((item, lo.to(self.prev_token.span))); expanded_attrs.push((item, lo.to(self.prev_token.span)));
@ -359,7 +359,7 @@ impl<'a> Parser<'a> {
pub(crate) fn parse_meta_seq_top(&mut self) -> PResult<'a, ThinVec<ast::NestedMetaItem>> { pub(crate) fn parse_meta_seq_top(&mut self) -> PResult<'a, ThinVec<ast::NestedMetaItem>> {
// Presumably, the majority of the time there will only be one attr. // Presumably, the majority of the time there will only be one attr.
let mut nmis = ThinVec::with_capacity(1); let mut nmis = ThinVec::with_capacity(1);
while self.token.kind != token::Eof { while self.token != token::Eof {
nmis.push(self.parse_meta_item_inner()?); nmis.push(self.parse_meta_item_inner()?);
if !self.eat(&token::Comma) { if !self.eat(&token::Comma) {
break; break;

55
compiler/rustc_parse/src/parser/diagnostics.rs
View file

@ -474,8 +474,8 @@ impl<'a> Parser<'a> {
// If this isn't the case however, and the suggestion is a token the // If this isn't the case however, and the suggestion is a token the
// content of which is the same as the found token's, we remove it as well. // content of which is the same as the found token's, we remove it as well.
if !eq { if !eq {
if let TokenType::Token(kind) = &token { if let TokenType::Token(kind) = token {
if kind == &self.token.kind { if self.token == *kind {
return false; return false;
} }
} }
@ -506,7 +506,7 @@ impl<'a> Parser<'a> {
} else if !sm.is_multiline(self.prev_token.span.until(self.token.span)) { } else if !sm.is_multiline(self.prev_token.span.until(self.token.span)) {
// The current token is in the same line as the prior token, not recoverable. // The current token is in the same line as the prior token, not recoverable.
} else if [token::Comma, token::Colon].contains(&self.token.kind) } else if [token::Comma, token::Colon].contains(&self.token.kind)
&& self.prev_token.kind == token::CloseDelim(Delimiter::Parenthesis) && self.prev_token == token::CloseDelim(Delimiter::Parenthesis)
{ {
// Likely typo: The current token is on a new line and is expected to be // Likely typo: The current token is on a new line and is expected to be
// `.`, `;`, `?`, or an operator after a close delimiter token. // `.`, `;`, `?`, or an operator after a close delimiter token.
@ -518,7 +518,7 @@ impl<'a> Parser<'a> {
// https://github.com/rust-lang/rust/issues/72253 // https://github.com/rust-lang/rust/issues/72253
} else if self.look_ahead(1, |t| { } else if self.look_ahead(1, |t| {
t == &token::CloseDelim(Delimiter::Brace) t == &token::CloseDelim(Delimiter::Brace)
|| t.can_begin_expr() && t.kind != token::Colon || t.can_begin_expr() && *t != token::Colon
}) && [token::Comma, token::Colon].contains(&self.token.kind) }) && [token::Comma, token::Colon].contains(&self.token.kind)
{ {
// Likely typo: `,` → `;` or `:` → `;`. This is triggered if the current token is // Likely typo: `,` → `;` or `:` → `;`. This is triggered if the current token is
@ -562,7 +562,7 @@ impl<'a> Parser<'a> {
} }
} }
if self.token.kind == TokenKind::EqEq if self.token == TokenKind::EqEq
&& self.prev_token.is_ident() && self.prev_token.is_ident()
&& expected.iter().any(|tok| matches!(tok, TokenType::Token(TokenKind::Eq))) && expected.iter().any(|tok| matches!(tok, TokenType::Token(TokenKind::Eq)))
{ {
@ -655,9 +655,9 @@ impl<'a> Parser<'a> {
// positive for a `cr#` that wasn't intended to start a c-string literal, but identifying // positive for a `cr#` that wasn't intended to start a c-string literal, but identifying
// that in the parser requires unbounded lookahead, so we only add a hint to the existing // that in the parser requires unbounded lookahead, so we only add a hint to the existing
// error rather than replacing it entirely. // error rather than replacing it entirely.
if ((self.prev_token.kind == TokenKind::Ident(sym::c, IdentIsRaw::No) if ((self.prev_token == TokenKind::Ident(sym::c, IdentIsRaw::No)
&& matches!(&self.token.kind, TokenKind::Literal(token::Lit { kind: token::Str, .. }))) && matches!(&self.token.kind, TokenKind::Literal(token::Lit { kind: token::Str, .. })))
|| (self.prev_token.kind == TokenKind::Ident(sym::cr, IdentIsRaw::No) || (self.prev_token == TokenKind::Ident(sym::cr, IdentIsRaw::No)
&& matches!( && matches!(
&self.token.kind, &self.token.kind,
TokenKind::Literal(token::Lit { kind: token::Str, .. }) | token::Pound TokenKind::Literal(token::Lit { kind: token::Str, .. }) | token::Pound
@ -673,7 +673,7 @@ impl<'a> Parser<'a> {
// `pub` may be used for an item or `pub(crate)` // `pub` may be used for an item or `pub(crate)`
if self.prev_token.is_ident_named(sym::public) if self.prev_token.is_ident_named(sym::public)
&& (self.token.can_begin_item() && (self.token.can_begin_item()
|| self.token.kind == TokenKind::OpenDelim(Delimiter::Parenthesis)) || self.token == TokenKind::OpenDelim(Delimiter::Parenthesis))
{ {
err.span_suggestion_short( err.span_suggestion_short(
self.prev_token.span, self.prev_token.span,
@ -772,7 +772,7 @@ impl<'a> Parser<'a> {
), ),
); );
if self.token == token::Pound if self.token == token::Pound
&& self.look_ahead(1, |t| t.kind == token::OpenDelim(Delimiter::Bracket)) && self.look_ahead(1, |t| *t == token::OpenDelim(Delimiter::Bracket))
{ {
// We have // We have
// #[attr] // #[attr]
@ -867,7 +867,7 @@ impl<'a> Parser<'a> {
let str_span = self.prev_token.span; let str_span = self.prev_token.span;
let mut span = self.token.span; let mut span = self.token.span;
let mut count = 0; let mut count = 0;
while self.token.kind == TokenKind::Pound while self.token == TokenKind::Pound
&& !sm.is_multiline(span.shrink_to_hi().until(self.token.span.shrink_to_lo())) && !sm.is_multiline(span.shrink_to_hi().until(self.token.span.shrink_to_lo()))
{ {
span = span.with_hi(self.token.span.hi()); span = span.with_hi(self.token.span.hi());
@ -1167,7 +1167,7 @@ impl<'a> Parser<'a> {
return; return;
} }
if token::PathSep == self.token.kind && segment.args.is_none() { if self.token == token::PathSep && segment.args.is_none() {
let snapshot = self.create_snapshot_for_diagnostic(); let snapshot = self.create_snapshot_for_diagnostic();
self.bump(); self.bump();
let lo = self.token.span; let lo = self.token.span;
@ -1176,13 +1176,11 @@ impl<'a> Parser<'a> {
let span = lo.to(self.prev_token.span); let span = lo.to(self.prev_token.span);
// Detect trailing `>` like in `x.collect::Vec<_>>()`. // Detect trailing `>` like in `x.collect::Vec<_>>()`.
let mut trailing_span = self.prev_token.span.shrink_to_hi(); let mut trailing_span = self.prev_token.span.shrink_to_hi();
while self.token.kind == token::BinOp(token::Shr) while self.token == token::BinOp(token::Shr) || self.token == token::Gt {
|| self.token.kind == token::Gt
{
trailing_span = trailing_span.to(self.token.span); trailing_span = trailing_span.to(self.token.span);
self.bump(); self.bump();
} }
if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) { if self.token == token::OpenDelim(Delimiter::Parenthesis) {
// Recover from bad turbofish: `foo.collect::Vec<_>()`. // Recover from bad turbofish: `foo.collect::Vec<_>()`.
segment.args = Some(AngleBracketedArgs { args, span }.into()); segment.args = Some(AngleBracketedArgs { args, span }.into());
@ -1430,7 +1428,7 @@ impl<'a> Parser<'a> {
self.restore_snapshot(snapshot); self.restore_snapshot(snapshot);
} }
} }
return if token::PathSep == self.token.kind { return if self.token == token::PathSep {
// We have some certainty that this was a bad turbofish at this point. // We have some certainty that this was a bad turbofish at this point.
// `foo< bar >::` // `foo< bar >::`
if let ExprKind::Binary(o, ..) = inner_op.kind if let ExprKind::Binary(o, ..) = inner_op.kind
@ -1462,7 +1460,7 @@ impl<'a> Parser<'a> {
Err(self.dcx().create_err(err)) Err(self.dcx().create_err(err))
} }
} }
} else if token::OpenDelim(Delimiter::Parenthesis) == self.token.kind { } else if self.token == token::OpenDelim(Delimiter::Parenthesis) {
// We have high certainty that this was a bad turbofish at this point. // We have high certainty that this was a bad turbofish at this point.
// `foo< bar >(` // `foo< bar >(`
if let ExprKind::Binary(o, ..) = inner_op.kind if let ExprKind::Binary(o, ..) = inner_op.kind
@ -1528,7 +1526,7 @@ impl<'a> Parser<'a> {
]; ];
self.consume_tts(1, &modifiers); self.consume_tts(1, &modifiers);
if self.token.kind == token::Eof { if self.token == token::Eof {
// Not entirely sure that what we consumed were fn arguments, rollback. // Not entirely sure that what we consumed were fn arguments, rollback.
self.restore_snapshot(snapshot); self.restore_snapshot(snapshot);
Err(()) Err(())
@ -1811,7 +1809,7 @@ impl<'a> Parser<'a> {
/// This function gets called in places where a semicolon is NOT expected and if there's a /// This function gets called in places where a semicolon is NOT expected and if there's a
/// semicolon it emits the appropriate error and returns true. /// semicolon it emits the appropriate error and returns true.
pub fn maybe_consume_incorrect_semicolon(&mut self, previous_item: Option<&Item>) -> bool { pub fn maybe_consume_incorrect_semicolon(&mut self, previous_item: Option<&Item>) -> bool {
if self.token.kind != TokenKind::Semi { if self.token != TokenKind::Semi {
return false; return false;
} }
@ -2405,10 +2403,10 @@ impl<'a> Parser<'a> {
modifier: &[(token::TokenKind, i64)], modifier: &[(token::TokenKind, i64)],
) { ) {
while acc > 0 { while acc > 0 {
if let Some((_, val)) = modifier.iter().find(|(t, _)| *t == self.token.kind) { if let Some((_, val)) = modifier.iter().find(|(t, _)| self.token == *t) {
acc += *val; acc += *val;
} }
if self.token.kind == token::Eof { if self.token == token::Eof {
break; break;
} }
self.bump(); self.bump();
@ -2598,7 +2596,7 @@ impl<'a> Parser<'a> {
} }
}) })
.is_some() .is_some()
|| self.token.kind == TokenKind::Dot; || self.token == TokenKind::Dot;
// This will be true when a trait object type `Foo +` or a path which was a `const fn` with // This will be true when a trait object type `Foo +` or a path which was a `const fn` with
// type params has been parsed. // type params has been parsed.
let was_op = let was_op =
@ -2617,7 +2615,7 @@ impl<'a> Parser<'a> {
})() { })() {
Ok(expr) => { Ok(expr) => {
// Find a mistake like `MyTrait<Assoc == S::Assoc>`. // Find a mistake like `MyTrait<Assoc == S::Assoc>`.
if token::EqEq == snapshot.token.kind { if snapshot.token == token::EqEq {
err.span_suggestion( err.span_suggestion(
snapshot.token.span, snapshot.token.span,
"if you meant to use an associated type binding, replace `==` with `=`", "if you meant to use an associated type binding, replace `==` with `=`",
@ -2627,7 +2625,7 @@ impl<'a> Parser<'a> {
let guar = err.emit(); let guar = err.emit();
let value = self.mk_expr_err(start.to(expr.span), guar); let value = self.mk_expr_err(start.to(expr.span), guar);
return Ok(GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value })); return Ok(GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value }));
} else if token::Colon == snapshot.token.kind } else if snapshot.token == token::Colon
&& expr.span.lo() == snapshot.token.span.hi() && expr.span.lo() == snapshot.token.span.hi()
&& matches!(expr.kind, ExprKind::Path(..)) && matches!(expr.kind, ExprKind::Path(..))
{ {
@ -2642,8 +2640,7 @@ impl<'a> Parser<'a> {
return Ok(GenericArg::Type( return Ok(GenericArg::Type(
self.mk_ty(start.to(expr.span), TyKind::Err(guar)), self.mk_ty(start.to(expr.span), TyKind::Err(guar)),
)); ));
} else if token::Comma == self.token.kind || self.token.kind.should_end_const_arg() } else if self.token == token::Comma || self.token.kind.should_end_const_arg() {
{
// Avoid the following output by checking that we consumed a full const arg: // Avoid the following output by checking that we consumed a full const arg:
// help: expressions must be enclosed in braces to be used as const generic // help: expressions must be enclosed in braces to be used as const generic
// arguments // arguments
@ -2846,8 +2843,8 @@ impl<'a> Parser<'a> {
pub(crate) fn maybe_recover_unexpected_block_label(&mut self) -> bool { pub(crate) fn maybe_recover_unexpected_block_label(&mut self) -> bool {
// Check for `'a : {` // Check for `'a : {`
if !(self.check_lifetime() if !(self.check_lifetime()
&& self.look_ahead(1, |tok| tok.kind == token::Colon) && self.look_ahead(1, |t| *t == token::Colon)
&& self.look_ahead(2, |tok| tok.kind == token::OpenDelim(Delimiter::Brace))) && self.look_ahead(2, |t| *t == token::OpenDelim(Delimiter::Brace)))
{ {
return false; return false;
} }
@ -3001,7 +2998,7 @@ impl<'a> Parser<'a> {
// >>>>>>> // >>>>>>>
let mut end = None; let mut end = None;
loop { loop {
if self.token.kind == TokenKind::Eof { if self.token == TokenKind::Eof {
break; break;
} }
if let Some(span) = self.conflict_marker(&TokenKind::OrOr, &TokenKind::BinOp(token::Or)) if let Some(span) = self.conflict_marker(&TokenKind::OrOr, &TokenKind::BinOp(token::Or))

71
compiler/rustc_parse/src/parser/expr.rs
View file

@ -165,7 +165,7 @@ impl<'a> Parser<'a> {
// Look for JS' `===` and `!==` and recover // Look for JS' `===` and `!==` and recover
if (op.node == AssocOp::Equal || op.node == AssocOp::NotEqual) if (op.node == AssocOp::Equal || op.node == AssocOp::NotEqual)
&& self.token.kind == token::Eq && self.token == token::Eq
&& self.prev_token.span.hi() == self.token.span.lo() && self.prev_token.span.hi() == self.token.span.lo()
{ {
let sp = op.span.to(self.token.span); let sp = op.span.to(self.token.span);
@ -190,7 +190,7 @@ impl<'a> Parser<'a> {
// Look for PHP's `<>` and recover // Look for PHP's `<>` and recover
if op.node == AssocOp::Less if op.node == AssocOp::Less
&& self.token.kind == token::Gt && self.token == token::Gt
&& self.prev_token.span.hi() == self.token.span.lo() && self.prev_token.span.hi() == self.token.span.lo()
{ {
let sp = op.span.to(self.token.span); let sp = op.span.to(self.token.span);
@ -208,7 +208,7 @@ impl<'a> Parser<'a> {
// Look for C++'s `<=>` and recover // Look for C++'s `<=>` and recover
if op.node == AssocOp::LessEqual if op.node == AssocOp::LessEqual
&& self.token.kind == token::Gt && self.token == token::Gt
&& self.prev_token.span.hi() == self.token.span.lo() && self.prev_token.span.hi() == self.token.span.lo()
{ {
let sp = op.span.to(self.token.span); let sp = op.span.to(self.token.span);
@ -882,7 +882,7 @@ impl<'a> Parser<'a> {
let mut res = ensure_sufficient_stack(|| { let mut res = ensure_sufficient_stack(|| {
loop { loop {
let has_question = let has_question =
if self.prev_token.kind == TokenKind::Ident(kw::Return, IdentIsRaw::No) { if self.prev_token == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
// We are using noexpect here because we don't expect a `?` directly after // We are using noexpect here because we don't expect a `?` directly after
// a `return` which could be suggested otherwise. // a `return` which could be suggested otherwise.
self.eat_noexpect(&token::Question) self.eat_noexpect(&token::Question)
@ -894,20 +894,19 @@ impl<'a> Parser<'a> {
e = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Try(e)); e = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Try(e));
continue; continue;
} }
let has_dot = let has_dot = if self.prev_token == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
if self.prev_token.kind == TokenKind::Ident(kw::Return, IdentIsRaw::No) { // We are using noexpect here because we don't expect a `.` directly after
// We are using noexpect here because we don't expect a `.` directly after // a `return` which could be suggested otherwise.
// a `return` which could be suggested otherwise. self.eat_noexpect(&token::Dot)
self.eat_noexpect(&token::Dot) } else if self.token == TokenKind::RArrow && self.may_recover() {
} else if self.token.kind == TokenKind::RArrow && self.may_recover() { // Recovery for `expr->suffix`.
// Recovery for `expr->suffix`. self.bump();
self.bump(); let span = self.prev_token.span;
let span = self.prev_token.span; self.dcx().emit_err(errors::ExprRArrowCall { span });
self.dcx().emit_err(errors::ExprRArrowCall { span }); true
true } else {
} else { self.eat(&token::Dot)
self.eat(&token::Dot) };
};
if has_dot { if has_dot {
// expr.f // expr.f
e = self.parse_dot_suffix_expr(lo, e)?; e = self.parse_dot_suffix_expr(lo, e)?;
@ -1206,7 +1205,7 @@ impl<'a> Parser<'a> {
} }
fn mk_expr_tuple_field_access( fn mk_expr_tuple_field_access(
&mut self, &self,
lo: Span, lo: Span,
ident_span: Span, ident_span: Span,
base: P<Expr>, base: P<Expr>,
@ -1221,7 +1220,7 @@ impl<'a> Parser<'a> {
/// Parse a function call expression, `expr(...)`. /// Parse a function call expression, `expr(...)`.
fn parse_expr_fn_call(&mut self, lo: Span, fun: P<Expr>) -> P<Expr> { fn parse_expr_fn_call(&mut self, lo: Span, fun: P<Expr>) -> P<Expr> {
let snapshot = if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) { let snapshot = if self.token == token::OpenDelim(Delimiter::Parenthesis) {
Some((self.create_snapshot_for_diagnostic(), fun.kind.clone())) Some((self.create_snapshot_for_diagnostic(), fun.kind.clone()))
} else { } else {
None None
@ -1585,7 +1584,7 @@ impl<'a> Parser<'a> {
// Suggests using '<=' if there is an error parsing qpath when the previous token // Suggests using '<=' if there is an error parsing qpath when the previous token
// is an '=' token. Only emits suggestion if the '<' token and '=' token are // is an '=' token. Only emits suggestion if the '<' token and '=' token are
// directly adjacent (i.e. '=<') // directly adjacent (i.e. '=<')
if maybe_eq_tok.kind == TokenKind::Eq && maybe_eq_tok.span.hi() == lt_span.lo() { if maybe_eq_tok == TokenKind::Eq && maybe_eq_tok.span.hi() == lt_span.lo() {
let eq_lt = maybe_eq_tok.span.to(lt_span); let eq_lt = maybe_eq_tok.span.to(lt_span);
err.span_suggestion(eq_lt, "did you mean", "<=", Applicability::Unspecified); err.span_suggestion(eq_lt, "did you mean", "<=", Applicability::Unspecified);
} }
@ -2230,7 +2229,7 @@ impl<'a> Parser<'a> {
return Ok(()); return Ok(());
} }
if self.token.kind == token::Comma { if self.token == token::Comma {
if !self.psess.source_map().is_multiline(prev_span.until(self.token.span)) { if !self.psess.source_map().is_multiline(prev_span.until(self.token.span)) {
return Ok(()); return Ok(());
} }
@ -2360,7 +2359,7 @@ impl<'a> Parser<'a> {
None => {} None => {}
} }
if self.token.kind == TokenKind::Semi if self.token == TokenKind::Semi
&& matches!(self.token_cursor.stack.last(), Some((.., Delimiter::Parenthesis))) && matches!(self.token_cursor.stack.last(), Some((.., Delimiter::Parenthesis)))
&& self.may_recover() && self.may_recover()
{ {
@ -2557,7 +2556,7 @@ impl<'a> Parser<'a> {
); );
} else { } else {
// Look for usages of '=>' where '>=' might be intended // Look for usages of '=>' where '>=' might be intended
if maybe_fatarrow.kind == token::FatArrow { if maybe_fatarrow == token::FatArrow {
err.span_suggestion( err.span_suggestion(
maybe_fatarrow.span, maybe_fatarrow.span,
"you might have meant to write a \"greater than or equal to\" comparison", "you might have meant to write a \"greater than or equal to\" comparison",
@ -2606,7 +2605,7 @@ impl<'a> Parser<'a> {
missing_let: None, missing_let: None,
comparison: None, comparison: None,
}; };
if self.prev_token.kind == token::BinOp(token::Or) { if self.prev_token == token::BinOp(token::Or) {
// This was part of a closure, the that part of the parser recover. // This was part of a closure, the that part of the parser recover.
return Err(self.dcx().create_err(err)); return Err(self.dcx().create_err(err));
} else { } else {
@ -2742,7 +2741,7 @@ impl<'a> Parser<'a> {
} }
fn parse_for_head(&mut self) -> PResult<'a, (P<Pat>, P<Expr>)> { fn parse_for_head(&mut self) -> PResult<'a, (P<Pat>, P<Expr>)> {
let begin_paren = if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) { let begin_paren = if self.token == token::OpenDelim(Delimiter::Parenthesis) {
// Record whether we are about to parse `for (`. // Record whether we are about to parse `for (`.
// This is used below for recovery in case of `for ( $stuff ) $block` // This is used below for recovery in case of `for ( $stuff ) $block`
// in which case we will suggest `for $stuff $block`. // in which case we will suggest `for $stuff $block`.
@ -2776,7 +2775,7 @@ impl<'a> Parser<'a> {
return Err(err); return Err(err);
} }
}; };
return if self.token.kind == token::CloseDelim(Delimiter::Parenthesis) { return if self.token == token::CloseDelim(Delimiter::Parenthesis) {
// We know for sure we have seen `for ($SOMETHING in $EXPR)`, so we recover the // We know for sure we have seen `for ($SOMETHING in $EXPR)`, so we recover the
// parser state and emit a targeted suggestion. // parser state and emit a targeted suggestion.
let span = vec![start_span, self.token.span]; let span = vec![start_span, self.token.span];
@ -2995,7 +2994,7 @@ impl<'a> Parser<'a> {
first_expr: &P<Expr>, first_expr: &P<Expr>,
arrow_span: Span, arrow_span: Span,
) -> Option<(Span, ErrorGuaranteed)> { ) -> Option<(Span, ErrorGuaranteed)> {
if self.token.kind != token::Semi { if self.token != token::Semi {
return None; return None;
} }
let start_snapshot = self.create_snapshot_for_diagnostic(); let start_snapshot = self.create_snapshot_for_diagnostic();
@ -3024,18 +3023,18 @@ impl<'a> Parser<'a> {
// We might have either a `,` -> `;` typo, or a block without braces. We need // We might have either a `,` -> `;` typo, or a block without braces. We need
// a more subtle parsing strategy. // a more subtle parsing strategy.
loop { loop {
if self.token.kind == token::CloseDelim(Delimiter::Brace) { if self.token == token::CloseDelim(Delimiter::Brace) {
// We have reached the closing brace of the `match` expression. // We have reached the closing brace of the `match` expression.
return Some(err(self, stmts)); return Some(err(self, stmts));
} }
if self.token.kind == token::Comma { if self.token == token::Comma {
self.restore_snapshot(start_snapshot); self.restore_snapshot(start_snapshot);
return None; return None;
} }
let pre_pat_snapshot = self.create_snapshot_for_diagnostic(); let pre_pat_snapshot = self.create_snapshot_for_diagnostic();
match self.parse_pat_no_top_alt(None, None) { match self.parse_pat_no_top_alt(None, None) {
Ok(_pat) => { Ok(_pat) => {
if self.token.kind == token::FatArrow { if self.token == token::FatArrow {
// Reached arm end. // Reached arm end.
self.restore_snapshot(pre_pat_snapshot); self.restore_snapshot(pre_pat_snapshot);
return Some(err(self, stmts)); return Some(err(self, stmts));
@ -3286,7 +3285,7 @@ impl<'a> Parser<'a> {
} }
fn parse_match_arm_pat_and_guard(&mut self) -> PResult<'a, (P<Pat>, Option<P<Expr>>)> { fn parse_match_arm_pat_and_guard(&mut self) -> PResult<'a, (P<Pat>, Option<P<Expr>>)> {
if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) { if self.token == token::OpenDelim(Delimiter::Parenthesis) {
// Detect and recover from `($pat if $cond) => $arm`. // Detect and recover from `($pat if $cond) => $arm`.
let left = self.token.span; let left = self.token.span;
match self.parse_pat_allow_top_alt( match self.parse_pat_allow_top_alt(
@ -3344,7 +3343,7 @@ impl<'a> Parser<'a> {
self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore); self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore);
let msg = "you might have meant to start a match arm after the match guard"; let msg = "you might have meant to start a match arm after the match guard";
if self.eat(&token::CloseDelim(Delimiter::Brace)) { if self.eat(&token::CloseDelim(Delimiter::Brace)) {
let applicability = if self.token.kind != token::FatArrow { let applicability = if self.token != token::FatArrow {
// We have high confidence that we indeed didn't have a struct // We have high confidence that we indeed didn't have a struct
// literal in the match guard, but rather we had some operation // literal in the match guard, but rather we had some operation
// that ended in a path, immediately followed by a block that was // that ended in a path, immediately followed by a block that was
@ -3565,7 +3564,7 @@ impl<'a> Parser<'a> {
&& self.look_ahead(1, |t| { && self.look_ahead(1, |t| {
AssocOp::from_token(t).is_some() AssocOp::from_token(t).is_some()
|| matches!(t.kind, token::OpenDelim(_)) || matches!(t.kind, token::OpenDelim(_))
|| t.kind == token::Dot || *t == token::Dot
}) })
{ {
// Looks like they tried to write a shorthand, complex expression. // Looks like they tried to write a shorthand, complex expression.
@ -3850,11 +3849,11 @@ impl<'a> Parser<'a> {
self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| { self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
let res = f(this, attrs)?; let res = f(this, attrs)?;
let trailing = (this.restrictions.contains(Restrictions::STMT_EXPR) let trailing = (this.restrictions.contains(Restrictions::STMT_EXPR)
&& this.token.kind == token::Semi) && this.token == token::Semi)
// FIXME: pass an additional condition through from the place // FIXME: pass an additional condition through from the place
// where we know we need a comma, rather than assuming that // where we know we need a comma, rather than assuming that
// `#[attr] expr,` always captures a trailing comma. // `#[attr] expr,` always captures a trailing comma.
|| this.token.kind == token::Comma; || this.token == token::Comma;
Ok((res, trailing)) Ok((res, trailing))
}) })
} }

2
compiler/rustc_parse/src/parser/generics.rs
View file

@ -393,7 +393,7 @@ impl<'a> Parser<'a> {
if let Some(struct_) = struct_ if let Some(struct_) = struct_
&& self.may_recover() && self.may_recover()
&& self.token.kind == token::OpenDelim(Delimiter::Parenthesis) && self.token == token::OpenDelim(Delimiter::Parenthesis)
{ {
snapshot = Some((struct_, self.create_snapshot_for_diagnostic())); snapshot = Some((struct_, self.create_snapshot_for_diagnostic()));
}; };

38
compiler/rustc_parse/src/parser/item.rs
View file

@ -354,7 +354,7 @@ impl<'a> Parser<'a> {
fn is_reuse_path_item(&mut self) -> bool { fn is_reuse_path_item(&mut self) -> bool {
// no: `reuse ::path` for compatibility reasons with macro invocations // no: `reuse ::path` for compatibility reasons with macro invocations
self.token.is_keyword(kw::Reuse) self.token.is_keyword(kw::Reuse)
&& self.look_ahead(1, |t| t.is_path_start() && t.kind != token::PathSep) && self.look_ahead(1, |t| t.is_path_start() && *t != token::PathSep)
} }
/// Are we sure this could not possibly be a macro invocation? /// Are we sure this could not possibly be a macro invocation?
@ -499,7 +499,7 @@ impl<'a> Parser<'a> {
let mut err = self.dcx().struct_span_err(end.span, msg); let mut err = self.dcx().struct_span_err(end.span, msg);
if end.is_doc_comment() { if end.is_doc_comment() {
err.span_label(end.span, "this doc comment doesn't document anything"); err.span_label(end.span, "this doc comment doesn't document anything");
} else if self.token.kind == TokenKind::Semi { } else if self.token == TokenKind::Semi {
err.span_suggestion_verbose( err.span_suggestion_verbose(
self.token.span, self.token.span,
"consider removing this semicolon", "consider removing this semicolon",
@ -777,12 +777,12 @@ impl<'a> Parser<'a> {
&& self && self
.span_to_snippet(self.prev_token.span) .span_to_snippet(self.prev_token.span)
.is_ok_and(|snippet| snippet == "}") .is_ok_and(|snippet| snippet == "}")
&& self.token.kind == token::Semi; && self.token == token::Semi;
let mut semicolon_span = self.token.span; let mut semicolon_span = self.token.span;
if !is_unnecessary_semicolon { if !is_unnecessary_semicolon {
// #105369, Detect spurious `;` before assoc fn body // #105369, Detect spurious `;` before assoc fn body
is_unnecessary_semicolon = self.token == token::OpenDelim(Delimiter::Brace) is_unnecessary_semicolon = self.token == token::OpenDelim(Delimiter::Brace)
&& self.prev_token.kind == token::Semi; && self.prev_token == token::Semi;
semicolon_span = self.prev_token.span; semicolon_span = self.prev_token.span;
} }
// We have to bail or we'll potentially never make progress. // We have to bail or we'll potentially never make progress.
@ -1194,7 +1194,7 @@ impl<'a> Parser<'a> {
// FIXME: This recovery should be tested better. // FIXME: This recovery should be tested better.
if safety == Safety::Default if safety == Safety::Default
&& self.token.is_keyword(kw::Unsafe) && self.token.is_keyword(kw::Unsafe)
&& self.look_ahead(1, |t| t.kind == token::OpenDelim(Delimiter::Brace)) && self.look_ahead(1, |t| *t == token::OpenDelim(Delimiter::Brace))
{ {
self.expect(&token::OpenDelim(Delimiter::Brace)).unwrap_err().emit(); self.expect(&token::OpenDelim(Delimiter::Brace)).unwrap_err().emit();
safety = Safety::Unsafe(self.token.span); safety = Safety::Unsafe(self.token.span);
@ -1258,7 +1258,7 @@ impl<'a> Parser<'a> {
&& self.is_keyword_ahead(1, &[kw::Extern]) && self.is_keyword_ahead(1, &[kw::Extern])
&& self.look_ahead( && self.look_ahead(
2 + self.look_ahead(2, |t| t.can_begin_string_literal() as usize), 2 + self.look_ahead(2, |t| t.can_begin_string_literal() as usize),
|t| t.kind == token::OpenDelim(Delimiter::Brace), |t| *t == token::OpenDelim(Delimiter::Brace),
) )
} }
@ -1343,7 +1343,7 @@ impl<'a> Parser<'a> {
) -> PResult<'a, (Ident, StaticItem)> { ) -> PResult<'a, (Ident, StaticItem)> {
let ident = self.parse_ident()?; let ident = self.parse_ident()?;
if self.token.kind == TokenKind::Lt && self.may_recover() { if self.token == TokenKind::Lt && self.may_recover() {
let generics = self.parse_generics()?; let generics = self.parse_generics()?;
self.dcx().emit_err(errors::StaticWithGenerics { span: generics.span }); self.dcx().emit_err(errors::StaticWithGenerics { span: generics.span });
} }
@ -1914,7 +1914,7 @@ impl<'a> Parser<'a> {
let mut err = self.dcx().struct_span_err(sp, msg); let mut err = self.dcx().struct_span_err(sp, msg);
if self.token.is_ident() if self.token.is_ident()
|| (self.token.kind == TokenKind::Pound || (self.token == TokenKind::Pound
&& (self.look_ahead(1, |t| t == &token::OpenDelim(Delimiter::Bracket)))) && (self.look_ahead(1, |t| t == &token::OpenDelim(Delimiter::Bracket))))
{ {
// This is likely another field, TokenKind::Pound is used for `#[..]` // This is likely another field, TokenKind::Pound is used for `#[..]`
@ -1937,8 +1937,8 @@ impl<'a> Parser<'a> {
fn expect_field_ty_separator(&mut self) -> PResult<'a, ()> { fn expect_field_ty_separator(&mut self) -> PResult<'a, ()> {
if let Err(err) = self.expect(&token::Colon) { if let Err(err) = self.expect(&token::Colon) {
let sm = self.psess.source_map(); let sm = self.psess.source_map();
let eq_typo = self.token.kind == token::Eq && self.look_ahead(1, |t| t.is_path_start()); let eq_typo = self.token == token::Eq && self.look_ahead(1, |t| t.is_path_start());
let semi_typo = self.token.kind == token::Semi let semi_typo = self.token == token::Semi
&& self.look_ahead(1, |t| { && self.look_ahead(1, |t| {
t.is_path_start() t.is_path_start()
// We check that we are in a situation like `foo; bar` to avoid bad suggestions // We check that we are in a situation like `foo; bar` to avoid bad suggestions
@ -1974,7 +1974,7 @@ impl<'a> Parser<'a> {
attrs: AttrVec, attrs: AttrVec,
) -> PResult<'a, FieldDef> { ) -> PResult<'a, FieldDef> {
let name = self.parse_field_ident(adt_ty, lo)?; let name = self.parse_field_ident(adt_ty, lo)?;
if self.token.kind == token::Not { if self.token == token::Not {
if let Err(mut err) = self.unexpected() { if let Err(mut err) = self.unexpected() {
// Encounter the macro invocation // Encounter the macro invocation
err.subdiagnostic(MacroExpandsToAdtField { adt_ty }); err.subdiagnostic(MacroExpandsToAdtField { adt_ty });
@ -1983,10 +1983,10 @@ impl<'a> Parser<'a> {
} }
self.expect_field_ty_separator()?; self.expect_field_ty_separator()?;
let ty = self.parse_ty_for_field_def()?; let ty = self.parse_ty_for_field_def()?;
if self.token.kind == token::Colon && self.look_ahead(1, |tok| tok.kind != token::Colon) { if self.token == token::Colon && self.look_ahead(1, |t| *t != token::Colon) {
self.dcx().emit_err(errors::SingleColonStructType { span: self.token.span }); self.dcx().emit_err(errors::SingleColonStructType { span: self.token.span });
} }
if self.token.kind == token::Eq { if self.token == token::Eq {
self.bump(); self.bump();
let const_expr = self.parse_expr_anon_const()?; let const_expr = self.parse_expr_anon_const()?;
let sp = ty.span.shrink_to_hi().to(const_expr.value.span); let sp = ty.span.shrink_to_hi().to(const_expr.value.span);
@ -2064,7 +2064,7 @@ impl<'a> Parser<'a> {
.parse_ident_common(false) .parse_ident_common(false)
// Cancel this error, we don't need it. // Cancel this error, we don't need it.
.map_err(|err| err.cancel()) .map_err(|err| err.cancel())
&& self.token.kind == TokenKind::Colon && self.token == TokenKind::Colon
{ {
err.span_suggestion( err.span_suggestion(
removal_span, removal_span,
@ -2367,12 +2367,12 @@ impl<'a> Parser<'a> {
match self.expected_one_of_not_found(&[], expected) { match self.expected_one_of_not_found(&[], expected) {
Ok(error_guaranteed) => Ok(error_guaranteed), Ok(error_guaranteed) => Ok(error_guaranteed),
Err(mut err) => { Err(mut err) => {
if self.token.kind == token::CloseDelim(Delimiter::Brace) { if self.token == token::CloseDelim(Delimiter::Brace) {
// The enclosing `mod`, `trait` or `impl` is being closed, so keep the `fn` in // The enclosing `mod`, `trait` or `impl` is being closed, so keep the `fn` in
// the AST for typechecking. // the AST for typechecking.
err.span_label(ident_span, "while parsing this `fn`"); err.span_label(ident_span, "while parsing this `fn`");
Ok(err.emit()) Ok(err.emit())
} else if self.token.kind == token::RArrow } else if self.token == token::RArrow
&& let Some(fn_params_end) = fn_params_end && let Some(fn_params_end) = fn_params_end
{ {
// Instead of a function body, the parser has encountered a right arrow // Instead of a function body, the parser has encountered a right arrow
@ -2445,7 +2445,7 @@ impl<'a> Parser<'a> {
fn_params_end: Option<Span>, fn_params_end: Option<Span>,
) -> PResult<'a, Option<P<Block>>> { ) -> PResult<'a, Option<P<Block>>> {
let has_semi = if req_body { let has_semi = if req_body {
self.token.kind == TokenKind::Semi self.token == TokenKind::Semi
} else { } else {
// Only include `;` in list of expected tokens if body is not required // Only include `;` in list of expected tokens if body is not required
self.check(&TokenKind::Semi) self.check(&TokenKind::Semi)
@ -2458,7 +2458,7 @@ impl<'a> Parser<'a> {
} else if self.check(&token::OpenDelim(Delimiter::Brace)) || self.token.is_whole_block() { } else if self.check(&token::OpenDelim(Delimiter::Brace)) || self.token.is_whole_block() {
self.parse_block_common(self.token.span, BlockCheckMode::Default, false) self.parse_block_common(self.token.span, BlockCheckMode::Default, false)
.map(|(attrs, body)| (attrs, Some(body)))? .map(|(attrs, body)| (attrs, Some(body)))?
} else if self.token.kind == token::Eq { } else if self.token == token::Eq {
// Recover `fn foo() = $expr;`. // Recover `fn foo() = $expr;`.
self.bump(); // `=` self.bump(); // `=`
let eq_sp = self.prev_token.span; let eq_sp = self.prev_token.span;
@ -2761,7 +2761,7 @@ impl<'a> Parser<'a> {
pub(super) fn parse_fn_params(&mut self, req_name: ReqName) -> PResult<'a, ThinVec<Param>> { pub(super) fn parse_fn_params(&mut self, req_name: ReqName) -> PResult<'a, ThinVec<Param>> {
let mut first_param = true; let mut first_param = true;
// Parse the arguments, starting out with `self` being allowed... // Parse the arguments, starting out with `self` being allowed...
if self.token.kind != TokenKind::OpenDelim(Delimiter::Parenthesis) if self.token != TokenKind::OpenDelim(Delimiter::Parenthesis)
// might be typo'd trait impl, handled elsewhere // might be typo'd trait impl, handled elsewhere
&& !self.token.is_keyword(kw::For) && !self.token.is_keyword(kw::For)
{ {

8
compiler/rustc_parse/src/parser/mod.rs
View file

@ -527,7 +527,7 @@ impl<'a> Parser<'a> {
} else if inedible.contains(&self.token.kind) { } else if inedible.contains(&self.token.kind) {
// leave it in the input // leave it in the input
Ok(Recovered::No) Ok(Recovered::No)
} else if self.token.kind != token::Eof } else if self.token != token::Eof
&& self.last_unexpected_token_span == Some(self.token.span) && self.last_unexpected_token_span == Some(self.token.span)
{ {
FatalError.raise(); FatalError.raise();
@ -756,7 +756,7 @@ impl<'a> Parser<'a> {
/// compound tokens like multi-character operators in process. /// compound tokens like multi-character operators in process.
/// Returns `true` if the token was eaten. /// Returns `true` if the token was eaten.
fn break_and_eat(&mut self, expected: TokenKind) -> bool { fn break_and_eat(&mut self, expected: TokenKind) -> bool {
if self.token.kind == expected { if self.token == expected {
self.bump(); self.bump();
return true; return true;
} }
@ -882,7 +882,7 @@ impl<'a> Parser<'a> {
let token_str = pprust::token_kind_to_string(t); let token_str = pprust::token_kind_to_string(t);
match self.current_closure.take() { match self.current_closure.take() {
Some(closure_spans) if self.token.kind == TokenKind::Semi => { Some(closure_spans) if self.token == TokenKind::Semi => {
// Finding a semicolon instead of a comma // Finding a semicolon instead of a comma
// after a closure body indicates that the // after a closure body indicates that the
// closure body may be a block but the user // closure body may be a block but the user
@ -910,7 +910,7 @@ impl<'a> Parser<'a> {
// If this was a missing `@` in a binding pattern // If this was a missing `@` in a binding pattern
// bail with a suggestion // bail with a suggestion
// https://github.com/rust-lang/rust/issues/72373 // https://github.com/rust-lang/rust/issues/72373
if self.prev_token.is_ident() && self.token.kind == token::DotDot { if self.prev_token.is_ident() && self.token == token::DotDot {
let msg = format!( let msg = format!(
"if you meant to bind the contents of the rest of the array \ "if you meant to bind the contents of the rest of the array \
pattern into `{}`, use `@`", pattern into `{}`, use `@`",

20
compiler/rustc_parse/src/parser/pat.rs
View file

@ -369,7 +369,7 @@ impl<'a> Parser<'a> {
.and_then(|(ident, _)| ident.name.as_str().chars().next()) .and_then(|(ident, _)| ident.name.as_str().chars().next())
.is_some_and(char::is_lowercase) .is_some_and(char::is_lowercase)
}) })
&& self.look_ahead(2, |tok| tok.kind == token::OpenDelim(Delimiter::Parenthesis)); && self.look_ahead(2, |t| *t == token::OpenDelim(Delimiter::Parenthesis));
// Check for operators. // Check for operators.
// `|` is excluded as it is used in pattern alternatives and lambdas, // `|` is excluded as it is used in pattern alternatives and lambdas,
@ -377,9 +377,9 @@ impl<'a> Parser<'a> {
// `[` is included for indexing operations, // `[` 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`) // `[]` is excluded as `a[]` isn't an expression and should be recovered as `a, []` (cf. `tests/ui/parser/pat-lt-bracket-7.rs`)
let has_trailing_operator = matches!(self.token.kind, token::BinOp(op) if op != BinOpToken::Or) let has_trailing_operator = matches!(self.token.kind, token::BinOp(op) if op != BinOpToken::Or)
|| self.token.kind == token::Question || self.token == token::Question
|| (self.token.kind == token::OpenDelim(Delimiter::Bracket) || (self.token == token::OpenDelim(Delimiter::Bracket)
&& self.look_ahead(1, |tok| tok.kind != token::CloseDelim(Delimiter::Bracket))); && self.look_ahead(1, |t| *t != token::CloseDelim(Delimiter::Bracket)));
if !has_trailing_method && !has_trailing_operator { if !has_trailing_method && !has_trailing_operator {
// Nothing to recover here. // Nothing to recover here.
@ -413,7 +413,7 @@ impl<'a> Parser<'a> {
let is_bound = is_end_bound let is_bound = is_end_bound
// is_start_bound: either `..` or `)..` // is_start_bound: either `..` or `)..`
|| self.token.is_range_separator() || self.token.is_range_separator()
|| self.token.kind == token::CloseDelim(Delimiter::Parenthesis) || self.token == token::CloseDelim(Delimiter::Parenthesis)
&& self.look_ahead(1, Token::is_range_separator); && self.look_ahead(1, Token::is_range_separator);
// Check that `parse_expr_assoc_with` didn't eat a rhs. // Check that `parse_expr_assoc_with` didn't eat a rhs.
@ -450,7 +450,7 @@ impl<'a> Parser<'a> {
lo = self.token.span; lo = self.token.span;
} }
let pat = if self.check(&token::BinOp(token::And)) || self.token.kind == token::AndAnd { let pat = if self.check(&token::BinOp(token::And)) || self.token == token::AndAnd {
self.parse_pat_deref(expected)? self.parse_pat_deref(expected)?
} else if self.check(&token::OpenDelim(Delimiter::Parenthesis)) { } else if self.check(&token::OpenDelim(Delimiter::Parenthesis)) {
self.parse_pat_tuple_or_parens()? self.parse_pat_tuple_or_parens()?
@ -625,7 +625,7 @@ impl<'a> Parser<'a> {
/// ///
/// [and]: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/pattern-matching /// [and]: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/pattern-matching
fn recover_intersection_pat(&mut self, lhs: P<Pat>) -> PResult<'a, P<Pat>> { fn recover_intersection_pat(&mut self, lhs: P<Pat>) -> PResult<'a, P<Pat>> {
if self.token.kind != token::At { if self.token != token::At {
// Next token is not `@` so it's not going to be an intersection pattern. // Next token is not `@` so it's not going to be an intersection pattern.
return Ok(lhs); return Ok(lhs);
} }
@ -958,14 +958,14 @@ impl<'a> Parser<'a> {
self.check_inline_const(dist) self.check_inline_const(dist)
|| self.look_ahead(dist, |t| { || self.look_ahead(dist, |t| {
t.is_path_start() // e.g. `MY_CONST`; t.is_path_start() // e.g. `MY_CONST`;
|| t.kind == token::Dot // e.g. `.5` for recovery; || *t == token::Dot // e.g. `.5` for recovery;
|| matches!(t.kind, token::Literal(..) | token::BinOp(token::Minus)) || matches!(t.kind, token::Literal(..) | token::BinOp(token::Minus))
|| t.is_bool_lit() || t.is_bool_lit()
|| t.is_whole_expr() || t.is_whole_expr()
|| t.is_lifetime() // recover `'a` instead of `'a'` || t.is_lifetime() // recover `'a` instead of `'a'`
|| (self.may_recover() // recover leading `(` || (self.may_recover() // recover leading `(`
&& t.kind == token::OpenDelim(Delimiter::Parenthesis) && *t == token::OpenDelim(Delimiter::Parenthesis)
&& self.look_ahead(dist + 1, |t| t.kind != token::OpenDelim(Delimiter::Parenthesis)) && self.look_ahead(dist + 1, |t| *t != token::OpenDelim(Delimiter::Parenthesis))
&& self.is_pat_range_end_start(dist + 1)) && self.is_pat_range_end_start(dist + 1))
}) })
} }

8
compiler/rustc_parse/src/parser/path.rs
View file

@ -358,9 +358,9 @@ impl<'a> Parser<'a> {
})?; })?;
let span = lo.to(self.prev_token.span); let span = lo.to(self.prev_token.span);
AngleBracketedArgs { args, span }.into() AngleBracketedArgs { args, span }.into()
} else if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) } else if self.token == token::OpenDelim(Delimiter::Parenthesis)
// FIXME(return_type_notation): Could also recover `...` here. // FIXME(return_type_notation): Could also recover `...` here.
&& self.look_ahead(1, |tok| tok.kind == token::DotDot) && self.look_ahead(1, |t| *t == token::DotDot)
{ {
self.bump(); // ( self.bump(); // (
self.bump(); // .. self.bump(); // ..
@ -384,7 +384,7 @@ impl<'a> Parser<'a> {
let token_before_parsing = self.token.clone(); let token_before_parsing = self.token.clone();
let mut snapshot = None; let mut snapshot = None;
if self.may_recover() if self.may_recover()
&& prev_token_before_parsing.kind == token::PathSep && prev_token_before_parsing == token::PathSep
&& (style == PathStyle::Expr && self.token.can_begin_expr() && (style == PathStyle::Expr && self.token.can_begin_expr()
|| style == PathStyle::Pat && self.token.can_begin_pattern()) || style == PathStyle::Pat && self.token.can_begin_pattern())
{ {
@ -393,7 +393,7 @@ impl<'a> Parser<'a> {
let (inputs, _) = match self.parse_paren_comma_seq(|p| p.parse_ty()) { let (inputs, _) = match self.parse_paren_comma_seq(|p| p.parse_ty()) {
Ok(output) => output, Ok(output) => output,
Err(mut error) if prev_token_before_parsing.kind == token::PathSep => { Err(mut error) if prev_token_before_parsing == token::PathSep => {
error.span_label( error.span_label(
prev_token_before_parsing.span.to(token_before_parsing.span), prev_token_before_parsing.span.to(token_before_parsing.span),
"while parsing this parenthesized list of type arguments starting here", "while parsing this parenthesized list of type arguments starting here",

4
compiler/rustc_parse/src/parser/stmt.rs
View file

@ -68,7 +68,7 @@ impl<'a> Parser<'a> {
self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| { self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| {
this.expect_keyword(kw::Let)?; this.expect_keyword(kw::Let)?;
let local = this.parse_local(attrs)?; let local = this.parse_local(attrs)?;
let trailing = capture_semi && this.token.kind == token::Semi; let trailing = capture_semi && this.token == token::Semi;
Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), trailing)) Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), trailing))
})? })?
} else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() { } else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() {
@ -760,7 +760,7 @@ impl<'a> Parser<'a> {
) )
), ),
); );
let suggest_eq = if self.token.kind == token::Dot let suggest_eq = if self.token == token::Dot
&& let _ = self.bump() && let _ = self.bump()
&& let mut snapshot = self.create_snapshot_for_diagnostic() && let mut snapshot = self.create_snapshot_for_diagnostic()
&& let Ok(_) = snapshot && let Ok(_) = snapshot

17
compiler/rustc_parse/src/parser/ty.rs
View file

@ -420,7 +420,7 @@ impl<'a> Parser<'a> {
let mut trailing_plus = false; let mut trailing_plus = false;
let (ts, trailing) = self.parse_paren_comma_seq(|p| { let (ts, trailing) = self.parse_paren_comma_seq(|p| {
let ty = p.parse_ty()?; let ty = p.parse_ty()?;
trailing_plus = p.prev_token.kind == TokenKind::BinOp(token::Plus); trailing_plus = p.prev_token == TokenKind::BinOp(token::Plus);
Ok(ty) Ok(ty)
})?; })?;
@ -499,8 +499,8 @@ impl<'a> Parser<'a> {
let elt_ty = match self.parse_ty() { let elt_ty = match self.parse_ty() {
Ok(ty) => ty, Ok(ty) => ty,
Err(err) Err(err)
if self.look_ahead(1, |t| t.kind == token::CloseDelim(Delimiter::Bracket)) if self.look_ahead(1, |t| *t == token::CloseDelim(Delimiter::Bracket))
| self.look_ahead(1, |t| t.kind == token::Semi) => | self.look_ahead(1, |t| *t == token::Semi) =>
{ {
// Recover from `[LIT; EXPR]` and `[LIT]` // Recover from `[LIT; EXPR]` and `[LIT]`
self.bump(); self.bump();
@ -601,7 +601,7 @@ impl<'a> Parser<'a> {
let span_start = self.token.span; let span_start = self.token.span;
let ast::FnHeader { ext, safety, constness, coroutine_kind } = let ast::FnHeader { ext, safety, constness, coroutine_kind } =
self.parse_fn_front_matter(&inherited_vis, Case::Sensitive)?; self.parse_fn_front_matter(&inherited_vis, Case::Sensitive)?;
if self.may_recover() && self.token.kind == TokenKind::Lt { if self.may_recover() && self.token == TokenKind::Lt {
self.recover_fn_ptr_with_generics(lo, &mut params, param_insertion_point)?; self.recover_fn_ptr_with_generics(lo, &mut params, param_insertion_point)?;
} }
let decl = self.parse_fn_decl(|_| false, AllowPlus::No, recover_return_sign)?; let decl = self.parse_fn_decl(|_| false, AllowPlus::No, recover_return_sign)?;
@ -681,7 +681,7 @@ impl<'a> Parser<'a> {
// Always parse bounds greedily for better error recovery. // Always parse bounds greedily for better error recovery.
let bounds = self.parse_generic_bounds()?; let bounds = self.parse_generic_bounds()?;
*impl_dyn_multi = bounds.len() > 1 || self.prev_token.kind == TokenKind::BinOp(token::Plus); *impl_dyn_multi = bounds.len() > 1 || self.prev_token == TokenKind::BinOp(token::Plus);
Ok(TyKind::ImplTrait(ast::DUMMY_NODE_ID, bounds)) Ok(TyKind::ImplTrait(ast::DUMMY_NODE_ID, bounds))
} }
@ -727,8 +727,7 @@ impl<'a> Parser<'a> {
self.check_keyword(kw::Dyn) self.check_keyword(kw::Dyn)
&& (self.token.uninterpolated_span().at_least_rust_2018() && (self.token.uninterpolated_span().at_least_rust_2018()
|| self.look_ahead(1, |t| { || self.look_ahead(1, |t| {
(can_begin_dyn_bound_in_edition_2015(t) (can_begin_dyn_bound_in_edition_2015(t) || *t == TokenKind::BinOp(token::Star))
|| t.kind == TokenKind::BinOp(token::Star))
&& !can_continue_type_after_non_fn_ident(t) && !can_continue_type_after_non_fn_ident(t)
})) }))
} }
@ -750,7 +749,7 @@ impl<'a> Parser<'a> {
// Always parse bounds greedily for better error recovery. // Always parse bounds greedily for better error recovery.
let bounds = self.parse_generic_bounds()?; let bounds = self.parse_generic_bounds()?;
*impl_dyn_multi = bounds.len() > 1 || self.prev_token.kind == TokenKind::BinOp(token::Plus); *impl_dyn_multi = bounds.len() > 1 || self.prev_token == TokenKind::BinOp(token::Plus);
Ok(TyKind::TraitObject(bounds, syntax)) Ok(TyKind::TraitObject(bounds, syntax))
} }
@ -1060,7 +1059,7 @@ impl<'a> Parser<'a> {
} }
let mut path = if self.token.is_keyword(kw::Fn) let mut path = if self.token.is_keyword(kw::Fn)
&& self.look_ahead(1, |tok| tok.kind == TokenKind::OpenDelim(Delimiter::Parenthesis)) && self.look_ahead(1, |t| *t == TokenKind::OpenDelim(Delimiter::Parenthesis))
&& let Some(path) = self.recover_path_from_fn() && let Some(path) = self.recover_path_from_fn()
{ {
path path

4
src/tools/clippy/clippy_dev/src/new_lint.rs
View file

@ -470,7 +470,7 @@ fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str>
}); });
// Find both the last lint declaration (declare_clippy_lint!) and the lint pass impl // Find both the last lint declaration (declare_clippy_lint!) and the lint pass impl
while let Some(LintDeclSearchResult { content, .. }) = iter.find(|result| result.token_kind == TokenKind::Ident) { while let Some(LintDeclSearchResult { content, .. }) = iter.find(|result| result.token == TokenKind::Ident) {
let mut iter = iter let mut iter = iter
.by_ref() .by_ref()
.filter(|t| !matches!(t.token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. })); .filter(|t| !matches!(t.token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. }));
@ -480,7 +480,7 @@ fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str>
// matches `!{` // matches `!{`
match_tokens!(iter, Bang OpenBrace); match_tokens!(iter, Bang OpenBrace);
if let Some(LintDeclSearchResult { range, .. }) = if let Some(LintDeclSearchResult { range, .. }) =
iter.find(|result| result.token_kind == TokenKind::CloseBrace) iter.find(|result| result.token == TokenKind::CloseBrace)
{ {
last_decl_curly_offset = Some(range.end); last_decl_curly_offset = Some(range.end);
} }

8
src/tools/rustfmt/src/parse/macros/mod.rs
View file

@ -84,9 +84,7 @@ pub(crate) struct ParsedMacroArgs {
fn check_keyword<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> { fn check_keyword<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
for &keyword in RUST_KW.iter() { for &keyword in RUST_KW.iter() {
if parser.token.is_keyword(keyword) if parser.token.is_keyword(keyword)
&& parser.look_ahead(1, |t| { && parser.look_ahead(1, |t| *t == TokenKind::Eof || *t == TokenKind::Comma)
t.kind == TokenKind::Eof || t.kind == TokenKind::Comma
})
{ {
parser.bump(); parser.bump();
return Some(MacroArg::Keyword( return Some(MacroArg::Keyword(
@ -131,7 +129,7 @@ pub(crate) fn parse_macro_args(
Some(arg) => { Some(arg) => {
args.push(arg); args.push(arg);
parser.bump(); parser.bump();
if parser.token.kind == TokenKind::Eof && args.len() == 2 { if parser.token == TokenKind::Eof && args.len() == 2 {
vec_with_semi = true; vec_with_semi = true;
break; break;
} }
@ -150,7 +148,7 @@ pub(crate) fn parse_macro_args(
parser.bump(); parser.bump();
if parser.token.kind == TokenKind::Eof { if parser.token == TokenKind::Eof {
trailing_comma = true; trailing_comma = true;
break; break;
} }