Rollup merge of #129065 - nnethercote:PartialEq-TokenKind, r=spastorino
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`
diff --git a/compiler/rustc_builtin_macros/src/asm.rs b/compiler/rustc_builtin_macros/src/asm.rs
index ed54c0c..ae2627d 100644
--- a/compiler/rustc_builtin_macros/src/asm.rs
+++ b/compiler/rustc_builtin_macros/src/asm.rs
@@ -328,7 +328,7 @@ pub fn parse_asm_args<'a>(
/// Otherwise, the suggestion will be incorrect.
fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
// 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 });
}
@@ -338,7 +338,7 @@ fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
/// Otherwise, the suggestion will be incorrect.
fn err_unsupported_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
// 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 });
}
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 6f17710..256713e 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -1154,7 +1154,7 @@ fn check_matcher_core<'tt>(
&& matches!(kind, NonterminalKind::Pat(PatParam { inferred: true }))
&& matches!(
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.
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 6b36944..5f6e7fb 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -1853,7 +1853,7 @@ fn check_tokens(&mut self, cx: &EarlyContext<'_>, tokens: &TokenStream) {
if !prev_dollar {
self.check_ident_token(cx, UnderMacro(true), ident);
}
- } else if token.kind == TokenKind::Dollar {
+ } else if *token == TokenKind::Dollar {
prev_dollar = true;
continue;
}
diff --git a/compiler/rustc_parse/src/lexer/tokentrees.rs b/compiler/rustc_parse/src/lexer/tokentrees.rs
index fb4ed5b..e7a7105 100644
--- a/compiler/rustc_parse/src/lexer/tokentrees.rs
+++ b/compiler/rustc_parse/src/lexer/tokentrees.rs
@@ -229,7 +229,7 @@ fn bump(&mut self, glue: bool) -> (Token, Spacing) {
} else {
let this_spacing = if next_tok.is_punct() {
Spacing::Joint
- } else if next_tok.kind == token::Eof {
+ } else if next_tok == token::Eof {
Spacing::Alone
} else {
Spacing::JointHidden
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index 8fdfbce..645fde2 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -162,7 +162,7 @@ fn annotate_following_item_if_applicable(
}
loop {
// 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) {
err.cancel();
return Some(replacement_span);
@@ -343,7 +343,7 @@ pub fn parse_cfg_attr(&mut self) -> PResult<'a, (ast::MetaItem, Vec<(ast::AttrIt
// Presumably, the majority of the time there will only be one attr.
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 item = self.parse_attr_item(ForceCollect::Yes)?;
expanded_attrs.push((item, lo.to(self.prev_token.span)));
@@ -359,7 +359,7 @@ pub fn parse_cfg_attr(&mut self) -> PResult<'a, (ast::MetaItem, Vec<(ast::AttrIt
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.
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()?);
if !self.eat(&token::Comma) {
break;
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 47ca85b..ba4e222 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -474,8 +474,8 @@ fn is_ident_eq_keyword(found: &TokenKind, expected: &TokenType) -> bool {
// 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.
if !eq {
- if let TokenType::Token(kind) = &token {
- if kind == &self.token.kind {
+ if let TokenType::Token(kind) = token {
+ if self.token == *kind {
return false;
}
}
@@ -506,7 +506,7 @@ fn is_ident_eq_keyword(found: &TokenKind, expected: &TokenType) -> bool {
} 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.
} 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
// `.`, `;`, `?`, or an operator after a close delimiter token.
@@ -518,7 +518,7 @@ fn is_ident_eq_keyword(found: &TokenKind, expected: &TokenType) -> bool {
// https://github.com/rust-lang/rust/issues/72253
} else if self.look_ahead(1, |t| {
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)
{
// Likely typo: `,` → `;` or `:` → `;`. This is triggered if the current token is
@@ -562,7 +562,7 @@ fn is_ident_eq_keyword(found: &TokenKind, expected: &TokenType) -> bool {
}
}
- if self.token.kind == TokenKind::EqEq
+ if self.token == TokenKind::EqEq
&& self.prev_token.is_ident()
&& expected.iter().any(|tok| matches!(tok, TokenType::Token(TokenKind::Eq)))
{
@@ -655,9 +655,9 @@ fn is_ident_eq_keyword(found: &TokenKind, expected: &TokenType) -> bool {
// 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
// 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, .. })))
- || (self.prev_token.kind == TokenKind::Ident(sym::cr, IdentIsRaw::No)
+ || (self.prev_token == TokenKind::Ident(sym::cr, IdentIsRaw::No)
&& matches!(
&self.token.kind,
TokenKind::Literal(token::Lit { kind: token::Str, .. }) | token::Pound
@@ -673,7 +673,7 @@ fn is_ident_eq_keyword(found: &TokenKind, expected: &TokenType) -> bool {
// `pub` may be used for an item or `pub(crate)`
if self.prev_token.is_ident_named(sym::public)
&& (self.token.can_begin_item()
- || self.token.kind == TokenKind::OpenDelim(Delimiter::Parenthesis))
+ || self.token == TokenKind::OpenDelim(Delimiter::Parenthesis))
{
err.span_suggestion_short(
self.prev_token.span,
@@ -772,7 +772,7 @@ pub(super) fn attr_on_non_tail_expr(&self, expr: &Expr) -> ErrorGuaranteed {
),
);
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
// #[attr]
@@ -867,7 +867,7 @@ fn check_too_many_raw_str_terminators(&mut self, err: &mut Diag<'_>) -> bool {
let str_span = self.prev_token.span;
let mut span = self.token.span;
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()))
{
span = span.with_hi(self.token.span.hi());
@@ -1167,7 +1167,7 @@ pub(super) fn check_turbofish_missing_angle_brackets(&mut self, segment: &mut Pa
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();
self.bump();
let lo = self.token.span;
@@ -1176,13 +1176,11 @@ pub(super) fn check_turbofish_missing_angle_brackets(&mut self, segment: &mut Pa
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.kind == token::BinOp(token::Shr)
- || self.token.kind == token::Gt
- {
+ while self.token == token::BinOp(token::Shr) || self.token == token::Gt {
trailing_span = trailing_span.to(self.token.span);
self.bump();
}
- if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) {
+ if self.token == token::OpenDelim(Delimiter::Parenthesis) {
// Recover from bad turbofish: `foo.collect::Vec<_>()`.
segment.args = Some(AngleBracketedArgs { args, span }.into());
@@ -1430,7 +1428,7 @@ pub(super) fn check_no_chained_comparison(
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.
// `foo< bar >::`
if let ExprKind::Binary(o, ..) = inner_op.kind
@@ -1462,7 +1460,7 @@ pub(super) fn check_no_chained_comparison(
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.
// `foo< bar >(`
if let ExprKind::Binary(o, ..) = inner_op.kind
@@ -1528,7 +1526,7 @@ fn consume_fn_args(&mut self) -> Result<(), ()> {
];
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.
self.restore_snapshot(snapshot);
Err(())
@@ -1811,7 +1809,7 @@ pub(super) fn maybe_recover_from_bad_qpath_stage_2<T: RecoverQPath>(
/// 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.
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;
}
@@ -2405,10 +2403,10 @@ fn consume_tts(
modifier: &[(token::TokenKind, i64)],
) {
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;
}
- if self.token.kind == token::Eof {
+ if self.token == token::Eof {
break;
}
self.bump();
@@ -2598,7 +2596,7 @@ pub(super) fn recover_const_arg(
}
})
.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
// type params has been parsed.
let was_op =
@@ -2617,7 +2615,7 @@ pub(super) fn recover_const_arg(
})() {
Ok(expr) => {
// Find a mistake like `MyTrait<Assoc == S::Assoc>`.
- if token::EqEq == snapshot.token.kind {
+ if snapshot.token == token::EqEq {
err.span_suggestion(
snapshot.token.span,
"if you meant to use an associated type binding, replace `==` with `=`",
@@ -2627,7 +2625,7 @@ pub(super) fn recover_const_arg(
let guar = err.emit();
let value = self.mk_expr_err(start.to(expr.span), guar);
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()
&& matches!(expr.kind, ExprKind::Path(..))
{
@@ -2642,8 +2640,7 @@ pub(super) fn recover_const_arg(
return Ok(GenericArg::Type(
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:
// help: expressions must be enclosed in braces to be used as const generic
// arguments
@@ -2846,8 +2843,8 @@ pub(crate) fn maybe_recover_colon_colon_in_pat_typo(
pub(crate) fn maybe_recover_unexpected_block_label(&mut self) -> bool {
// Check for `'a : {`
if !(self.check_lifetime()
- && self.look_ahead(1, |tok| tok.kind == token::Colon)
- && self.look_ahead(2, |tok| tok.kind == token::OpenDelim(Delimiter::Brace)))
+ && self.look_ahead(1, |t| *t == token::Colon)
+ && self.look_ahead(2, |t| *t == token::OpenDelim(Delimiter::Brace)))
{
return false;
}
@@ -3001,7 +2998,7 @@ pub(crate) fn err_vcs_conflict_marker(&mut self) -> PResult<'a, ()> {
// >>>>>>>
let mut end = None;
loop {
- if self.token.kind == TokenKind::Eof {
+ if self.token == TokenKind::Eof {
break;
}
if let Some(span) = self.conflict_marker(&TokenKind::OrOr, &TokenKind::BinOp(token::Or))
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index cf5d657..536160c 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -165,7 +165,7 @@ pub(super) fn parse_expr_assoc_rest_with(
// Look for JS' `===` and `!==` and recover
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()
{
let sp = op.span.to(self.token.span);
@@ -190,7 +190,7 @@ pub(super) fn parse_expr_assoc_rest_with(
// Look for PHP's `<>` and recover
if op.node == AssocOp::Less
- && self.token.kind == token::Gt
+ && self.token == token::Gt
&& self.prev_token.span.hi() == self.token.span.lo()
{
let sp = op.span.to(self.token.span);
@@ -208,7 +208,7 @@ pub(super) fn parse_expr_assoc_rest_with(
// Look for C++'s `<=>` and recover
if op.node == AssocOp::LessEqual
- && self.token.kind == token::Gt
+ && self.token == token::Gt
&& self.prev_token.span.hi() == self.token.span.lo()
{
let sp = op.span.to(self.token.span);
@@ -882,7 +882,7 @@ pub(super) fn parse_expr_dot_or_call_with(
let mut res = ensure_sufficient_stack(|| {
loop {
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
// a `return` which could be suggested otherwise.
self.eat_noexpect(&token::Question)
@@ -894,20 +894,19 @@ pub(super) fn parse_expr_dot_or_call_with(
e = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Try(e));
continue;
}
- let has_dot =
- if self.prev_token.kind == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
- // We are using noexpect here because we don't expect a `.` directly after
- // a `return` which could be suggested otherwise.
- self.eat_noexpect(&token::Dot)
- } else if self.token.kind == TokenKind::RArrow && self.may_recover() {
- // Recovery for `expr->suffix`.
- self.bump();
- let span = self.prev_token.span;
- self.dcx().emit_err(errors::ExprRArrowCall { span });
- true
- } else {
- self.eat(&token::Dot)
- };
+ let has_dot = if self.prev_token == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
+ // We are using noexpect here because we don't expect a `.` directly after
+ // a `return` which could be suggested otherwise.
+ self.eat_noexpect(&token::Dot)
+ } else if self.token == TokenKind::RArrow && self.may_recover() {
+ // Recovery for `expr->suffix`.
+ self.bump();
+ let span = self.prev_token.span;
+ self.dcx().emit_err(errors::ExprRArrowCall { span });
+ true
+ } else {
+ self.eat(&token::Dot)
+ };
if has_dot {
// expr.f
e = self.parse_dot_suffix_expr(lo, e)?;
@@ -1206,7 +1205,7 @@ fn parse_floating_field_access(&mut self) -> PResult<'a, P<[Ident]>> {
}
fn mk_expr_tuple_field_access(
- &mut self,
+ &self,
lo: Span,
ident_span: Span,
base: P<Expr>,
@@ -1221,7 +1220,7 @@ fn mk_expr_tuple_field_access(
/// Parse a function call expression, `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()))
} else {
None
@@ -1585,7 +1584,7 @@ fn parse_expr_path_start(&mut self) -> PResult<'a, P<Expr>> {
// 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
// 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);
err.span_suggestion(eq_lt, "did you mean", "<=", Applicability::Unspecified);
}
@@ -2230,7 +2229,7 @@ fn suggest_missing_semicolon_before_array(
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)) {
return Ok(());
}
@@ -2360,7 +2359,7 @@ fn parse_expr_closure(&mut self) -> PResult<'a, P<Expr>> {
None => {}
}
- if self.token.kind == TokenKind::Semi
+ if self.token == TokenKind::Semi
&& matches!(self.token_cursor.stack.last(), Some((.., Delimiter::Parenthesis)))
&& self.may_recover()
{
@@ -2557,7 +2556,7 @@ fn parse_if_after_cond(&mut self, lo: Span, mut cond: P<Expr>) -> PResult<'a, P<
);
} else {
// Look for usages of '=>' where '>=' might be intended
- if maybe_fatarrow.kind == token::FatArrow {
+ if maybe_fatarrow == token::FatArrow {
err.span_suggestion(
maybe_fatarrow.span,
"you might have meant to write a \"greater than or equal to\" comparison",
@@ -2606,7 +2605,7 @@ fn parse_expr_let(&mut self, restrictions: Restrictions) -> PResult<'a, P<Expr>>
missing_let: 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.
return Err(self.dcx().create_err(err));
} else {
@@ -2742,7 +2741,7 @@ fn error_on_extra_if(&mut self, cond: &P<Expr>) -> PResult<'a, ()> {
}
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 (`.
// This is used below for recovery in case of `for ( $stuff ) $block`
// in which case we will suggest `for $stuff $block`.
@@ -2776,7 +2775,7 @@ fn parse_for_head(&mut self) -> PResult<'a, (P<Pat>, P<Expr>)> {
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
// parser state and emit a targeted suggestion.
let span = vec![start_span, self.token.span];
@@ -2995,7 +2994,7 @@ fn parse_arm_body_missing_braces(
first_expr: &P<Expr>,
arrow_span: Span,
) -> Option<(Span, ErrorGuaranteed)> {
- if self.token.kind != token::Semi {
+ if self.token != token::Semi {
return None;
}
let start_snapshot = self.create_snapshot_for_diagnostic();
@@ -3024,18 +3023,18 @@ fn parse_arm_body_missing_braces(
// We might have either a `,` -> `;` typo, or a block without braces. We need
// a more subtle parsing strategy.
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.
return Some(err(self, stmts));
}
- if self.token.kind == token::Comma {
+ if self.token == token::Comma {
self.restore_snapshot(start_snapshot);
return None;
}
let pre_pat_snapshot = self.create_snapshot_for_diagnostic();
match self.parse_pat_no_top_alt(None, None) {
Ok(_pat) => {
- if self.token.kind == token::FatArrow {
+ if self.token == token::FatArrow {
// Reached arm end.
self.restore_snapshot(pre_pat_snapshot);
return Some(err(self, stmts));
@@ -3286,7 +3285,7 @@ fn check_let_expr(expr: &Expr) -> (bool, bool) {
}
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`.
let left = self.token.span;
match self.parse_pat_allow_top_alt(
@@ -3344,7 +3343,7 @@ fn parse_match_guard_condition(&mut self) -> PResult<'a, P<Expr>> {
self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore);
let msg = "you might have meant to start a match arm after the match guard";
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
// literal in the match guard, but rather we had some operation
// that ended in a path, immediately followed by a block that was
@@ -3565,7 +3564,7 @@ pub(super) fn parse_struct_fields(
&& self.look_ahead(1, |t| {
AssocOp::from_token(t).is_some()
|| matches!(t.kind, token::OpenDelim(_))
- || t.kind == token::Dot
+ || *t == token::Dot
})
{
// Looks like they tried to write a shorthand, complex expression.
@@ -3850,11 +3849,11 @@ fn collect_tokens_for_expr(
self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
let res = f(this, attrs)?;
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
// where we know we need a comma, rather than assuming that
// `#[attr] expr,` always captures a trailing comma.
- || this.token.kind == token::Comma;
+ || this.token == token::Comma;
Ok((res, trailing))
})
}
diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs
index 9124c15..f1bb718 100644
--- a/compiler/rustc_parse/src/parser/generics.rs
+++ b/compiler/rustc_parse/src/parser/generics.rs
@@ -393,7 +393,7 @@ fn parse_ty_where_predicate_or_recover_tuple_struct_body(
if let Some(struct_) = struct_
&& self.may_recover()
- && self.token.kind == token::OpenDelim(Delimiter::Parenthesis)
+ && self.token == token::OpenDelim(Delimiter::Parenthesis)
{
snapshot = Some((struct_, self.create_snapshot_for_diagnostic()));
};
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 8775d79..e34e82b 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -354,7 +354,7 @@ pub(super) fn is_path_start_item(&mut self) -> bool {
fn is_reuse_path_item(&mut self) -> bool {
// no: `reuse ::path` for compatibility reasons with macro invocations
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?
@@ -499,7 +499,7 @@ fn recover_attrs_no_item(&mut self, attrs: &[Attribute]) -> PResult<'a, ()> {
let mut err = self.dcx().struct_span_err(end.span, msg);
if end.is_doc_comment() {
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(
self.token.span,
"consider removing this semicolon",
@@ -777,12 +777,12 @@ fn parse_item_list<T>(
&& self
.span_to_snippet(self.prev_token.span)
.is_ok_and(|snippet| snippet == "}")
- && self.token.kind == token::Semi;
+ && self.token == token::Semi;
let mut semicolon_span = self.token.span;
if !is_unnecessary_semicolon {
// #105369, Detect spurious `;` before assoc fn body
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;
}
// We have to bail or we'll potentially never make progress.
@@ -1194,7 +1194,7 @@ fn parse_item_foreign_mod(
// FIXME: This recovery should be tested better.
if safety == Safety::Default
&& 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();
safety = Safety::Unsafe(self.token.span);
@@ -1258,7 +1258,7 @@ fn is_unsafe_foreign_mod(&self) -> bool {
&& self.is_keyword_ahead(1, &[kw::Extern])
&& self.look_ahead(
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 @@ fn parse_static_item(
) -> PResult<'a, (Ident, StaticItem)> {
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()?;
self.dcx().emit_err(errors::StaticWithGenerics { span: generics.span });
}
@@ -1914,7 +1914,7 @@ fn parse_single_struct_field(
let mut err = self.dcx().struct_span_err(sp, msg);
if self.token.is_ident()
- || (self.token.kind == TokenKind::Pound
+ || (self.token == TokenKind::Pound
&& (self.look_ahead(1, |t| t == &token::OpenDelim(Delimiter::Bracket))))
{
// This is likely another field, TokenKind::Pound is used for `#[..]`
@@ -1937,8 +1937,8 @@ fn parse_single_struct_field(
fn expect_field_ty_separator(&mut self) -> PResult<'a, ()> {
if let Err(err) = self.expect(&token::Colon) {
let sm = self.psess.source_map();
- let eq_typo = self.token.kind == token::Eq && self.look_ahead(1, |t| t.is_path_start());
- let semi_typo = self.token.kind == token::Semi
+ let eq_typo = self.token == token::Eq && self.look_ahead(1, |t| t.is_path_start());
+ let semi_typo = self.token == token::Semi
&& self.look_ahead(1, |t| {
t.is_path_start()
// We check that we are in a situation like `foo; bar` to avoid bad suggestions
@@ -1974,7 +1974,7 @@ fn parse_name_and_ty(
attrs: AttrVec,
) -> PResult<'a, FieldDef> {
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() {
// Encounter the macro invocation
err.subdiagnostic(MacroExpandsToAdtField { adt_ty });
@@ -1983,10 +1983,10 @@ fn parse_name_and_ty(
}
self.expect_field_ty_separator()?;
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 });
}
- if self.token.kind == token::Eq {
+ if self.token == token::Eq {
self.bump();
let const_expr = self.parse_expr_anon_const()?;
let sp = ty.span.shrink_to_hi().to(const_expr.value.span);
@@ -2064,7 +2064,7 @@ fn parse_field_ident(&mut self, adt_ty: &str, lo: Span) -> PResult<'a, Ident> {
.parse_ident_common(false)
// Cancel this error, we don't need it.
.map_err(|err| err.cancel())
- && self.token.kind == TokenKind::Colon
+ && self.token == TokenKind::Colon
{
err.span_suggestion(
removal_span,
@@ -2367,12 +2367,12 @@ fn error_fn_body_not_found(
match self.expected_one_of_not_found(&[], expected) {
Ok(error_guaranteed) => Ok(error_guaranteed),
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 AST for typechecking.
err.span_label(ident_span, "while parsing this `fn`");
Ok(err.emit())
- } else if self.token.kind == token::RArrow
+ } else if self.token == token::RArrow
&& let Some(fn_params_end) = fn_params_end
{
// Instead of a function body, the parser has encountered a right arrow
@@ -2445,7 +2445,7 @@ fn parse_fn_body(
fn_params_end: Option<Span>,
) -> PResult<'a, Option<P<Block>>> {
let has_semi = if req_body {
- self.token.kind == TokenKind::Semi
+ self.token == TokenKind::Semi
} else {
// Only include `;` in list of expected tokens if body is not required
self.check(&TokenKind::Semi)
@@ -2458,7 +2458,7 @@ fn parse_fn_body(
} else if self.check(&token::OpenDelim(Delimiter::Brace)) || self.token.is_whole_block() {
self.parse_block_common(self.token.span, BlockCheckMode::Default, false)
.map(|(attrs, body)| (attrs, Some(body)))?
- } else if self.token.kind == token::Eq {
+ } else if self.token == token::Eq {
// Recover `fn foo() = $expr;`.
self.bump(); // `=`
let eq_sp = self.prev_token.span;
@@ -2761,7 +2761,7 @@ pub(super) fn parse_fn_decl(
pub(super) fn parse_fn_params(&mut self, req_name: ReqName) -> PResult<'a, ThinVec<Param>> {
let mut first_param = true;
// 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
&& !self.token.is_keyword(kw::For)
{
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 9b3b6d5..db74ea6 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -527,7 +527,7 @@ fn expect_one_of(
} else if inedible.contains(&self.token.kind) {
// leave it in the input
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)
{
FatalError.raise();
@@ -756,7 +756,7 @@ fn check_plus(&mut self) -> bool {
/// compound tokens like multi-character operators in process.
/// Returns `true` if the token was eaten.
fn break_and_eat(&mut self, expected: TokenKind) -> bool {
- if self.token.kind == expected {
+ if self.token == expected {
self.bump();
return true;
}
@@ -882,7 +882,7 @@ fn parse_seq_to_before_tokens<T>(
let token_str = pprust::token_kind_to_string(t);
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
// after a closure body indicates that the
// closure body may be a block but the user
@@ -910,7 +910,7 @@ fn parse_seq_to_before_tokens<T>(
// If this was a missing `@` in a binding pattern
// bail with a suggestion
// 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!(
"if you meant to bind the contents of the rest of the array \
pattern into `{}`, use `@`",
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 5bfb8bd..089da1f 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -369,7 +369,7 @@ fn maybe_recover_trailing_expr(
.and_then(|(ident, _)| ident.name.as_str().chars().next())
.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.
// `|` is excluded as it is used in pattern alternatives and lambdas,
@@ -377,9 +377,9 @@ fn maybe_recover_trailing_expr(
// `[` 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`)
let has_trailing_operator = matches!(self.token.kind, token::BinOp(op) if op != BinOpToken::Or)
- || self.token.kind == token::Question
- || (self.token.kind == token::OpenDelim(Delimiter::Bracket)
- && self.look_ahead(1, |tok| tok.kind != token::CloseDelim(Delimiter::Bracket)));
+ || self.token == token::Question
+ || (self.token == token::OpenDelim(Delimiter::Bracket)
+ && self.look_ahead(1, |t| *t != token::CloseDelim(Delimiter::Bracket)));
if !has_trailing_method && !has_trailing_operator {
// Nothing to recover here.
@@ -413,7 +413,7 @@ fn maybe_recover_trailing_expr(
let is_bound = is_end_bound
// is_start_bound: either `..` or `)..`
|| 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);
// Check that `parse_expr_assoc_with` didn't eat a rhs.
@@ -450,7 +450,7 @@ fn parse_pat_with_range_pat(
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)?
} else if self.check(&token::OpenDelim(Delimiter::Parenthesis)) {
self.parse_pat_tuple_or_parens()?
@@ -625,7 +625,7 @@ fn recover_dotdotdot_rest_pat(&mut self, lo: Span) -> PatKind {
///
/// [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>> {
- 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.
return Ok(lhs);
}
@@ -958,14 +958,14 @@ fn is_pat_range_end_start(&self, dist: usize) -> bool {
self.check_inline_const(dist)
|| self.look_ahead(dist, |t| {
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))
|| t.is_bool_lit()
|| t.is_whole_expr()
|| t.is_lifetime() // recover `'a` instead of `'a'`
|| (self.may_recover() // recover leading `(`
- && t.kind == token::OpenDelim(Delimiter::Parenthesis)
- && self.look_ahead(dist + 1, |t| t.kind != token::OpenDelim(Delimiter::Parenthesis))
+ && *t == token::OpenDelim(Delimiter::Parenthesis)
+ && self.look_ahead(dist + 1, |t| *t != token::OpenDelim(Delimiter::Parenthesis))
&& self.is_pat_range_end_start(dist + 1))
})
}
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index 6f82d6b..007d760 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -358,9 +358,9 @@ pub(super) fn parse_path_segment(
})?;
let span = lo.to(self.prev_token.span);
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.
- && self.look_ahead(1, |tok| tok.kind == token::DotDot)
+ && self.look_ahead(1, |t| *t == token::DotDot)
{
self.bump(); // (
self.bump(); // ..
@@ -384,7 +384,7 @@ pub(super) fn parse_path_segment(
let token_before_parsing = self.token.clone();
let mut snapshot = None;
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::Pat && self.token.can_begin_pattern())
{
@@ -393,7 +393,7 @@ pub(super) fn parse_path_segment(
let (inputs, _) = match self.parse_paren_comma_seq(|p| p.parse_ty()) {
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(
prev_token_before_parsing.span.to(token_before_parsing.span),
"while parsing this parenthesized list of type arguments starting here",
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index b206f13..c4fc0df 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -68,7 +68,7 @@ pub fn parse_stmt_without_recovery(
self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| {
this.expect_keyword(kw::Let)?;
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))
})?
} else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() {
@@ -760,7 +760,7 @@ pub fn parse_full_stmt(
)
),
);
- let suggest_eq = if self.token.kind == token::Dot
+ let suggest_eq = if self.token == token::Dot
&& let _ = self.bump()
&& let mut snapshot = self.create_snapshot_for_diagnostic()
&& let Ok(_) = snapshot
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 352ddd9..a8e8270 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -420,7 +420,7 @@ fn parse_ty_tuple_or_parens(&mut self, lo: Span, allow_plus: AllowPlus) -> PResu
let mut trailing_plus = false;
let (ts, trailing) = self.parse_paren_comma_seq(|p| {
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)
})?;
@@ -499,8 +499,8 @@ fn parse_array_or_slice_ty(&mut self) -> PResult<'a, TyKind> {
let elt_ty = match self.parse_ty() {
Ok(ty) => ty,
Err(err)
- if self.look_ahead(1, |t| t.kind == token::CloseDelim(Delimiter::Bracket))
- | self.look_ahead(1, |t| t.kind == token::Semi) =>
+ if self.look_ahead(1, |t| *t == token::CloseDelim(Delimiter::Bracket))
+ | self.look_ahead(1, |t| *t == token::Semi) =>
{
// Recover from `[LIT; EXPR]` and `[LIT]`
self.bump();
@@ -601,7 +601,7 @@ fn parse_ty_bare_fn(
let span_start = self.token.span;
let ast::FnHeader { ext, safety, constness, coroutine_kind } =
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)?;
}
let decl = self.parse_fn_decl(|_| false, AllowPlus::No, recover_return_sign)?;
@@ -681,7 +681,7 @@ fn parse_impl_ty(&mut self, impl_dyn_multi: &mut bool) -> PResult<'a, TyKind> {
// Always parse bounds greedily for better error recovery.
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))
}
@@ -727,8 +727,7 @@ fn is_explicit_dyn_type(&mut self) -> bool {
self.check_keyword(kw::Dyn)
&& (self.token.uninterpolated_span().at_least_rust_2018()
|| self.look_ahead(1, |t| {
- (can_begin_dyn_bound_in_edition_2015(t)
- || t.kind == TokenKind::BinOp(token::Star))
+ (can_begin_dyn_bound_in_edition_2015(t) || *t == TokenKind::BinOp(token::Star))
&& !can_continue_type_after_non_fn_ident(t)
}))
}
@@ -750,7 +749,7 @@ fn parse_dyn_ty(&mut self, impl_dyn_multi: &mut bool) -> PResult<'a, TyKind> {
// Always parse bounds greedily for better error recovery.
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))
}
@@ -1060,7 +1059,7 @@ fn parse_generic_ty_bound(
}
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()
{
path
diff --git a/src/tools/clippy/clippy_dev/src/new_lint.rs b/src/tools/clippy/clippy_dev/src/new_lint.rs
index de91233..8711783 100644
--- a/src/tools/clippy/clippy_dev/src/new_lint.rs
+++ b/src/tools/clippy/clippy_dev/src/new_lint.rs
@@ -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
- 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
.by_ref()
.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 `!{`
match_tokens!(iter, Bang OpenBrace);
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);
}
diff --git a/src/tools/rustfmt/src/parse/macros/mod.rs b/src/tools/rustfmt/src/parse/macros/mod.rs
index 60c827f..8d5f7f9 100644
--- a/src/tools/rustfmt/src/parse/macros/mod.rs
+++ b/src/tools/rustfmt/src/parse/macros/mod.rs
@@ -84,9 +84,7 @@ pub(crate) struct ParsedMacroArgs {
fn check_keyword<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
for &keyword in RUST_KW.iter() {
if parser.token.is_keyword(keyword)
- && parser.look_ahead(1, |t| {
- t.kind == TokenKind::Eof || t.kind == TokenKind::Comma
- })
+ && parser.look_ahead(1, |t| *t == TokenKind::Eof || *t == TokenKind::Comma)
{
parser.bump();
return Some(MacroArg::Keyword(
@@ -131,7 +129,7 @@ pub(crate) fn parse_macro_args(
Some(arg) => {
args.push(arg);
parser.bump();
- if parser.token.kind == TokenKind::Eof && args.len() == 2 {
+ if parser.token == TokenKind::Eof && args.len() == 2 {
vec_with_semi = true;
break;
}
@@ -150,7 +148,7 @@ pub(crate) fn parse_macro_args(
parser.bump();
- if parser.token.kind == TokenKind::Eof {
+ if parser.token == TokenKind::Eof {
trailing_comma = true;
break;
}
