diff --git a/crates/ruff_python_parser/src/parser/expression.rs b/crates/ruff_python_parser/src/parser/expression.rs
index e7c343e907..6a8ebfc2c4 100644
--- a/crates/ruff_python_parser/src/parser/expression.rs
+++ b/crates/ruff_python_parser/src/parser/expression.rs
@@ -109,7 +109,7 @@ impl<'src> Parser<'src> {
     fn current_op(&mut self) -> (Precedence, TokenKind, Associativity) {
         const NOT_AN_OP: (Precedence, TokenKind, Associativity) =
             (Precedence::Unknown, TokenKind::Unknown, Associativity::Left);
-        let kind = self.current_kind();
+        let kind = self.current_token_kind();
 
         match kind {
             TokenKind::Or => (Precedence::Or, kind, Associativity::Left),
@@ -209,7 +209,7 @@ impl<'src> Parser<'src> {
 
     pub(super) fn parse_lhs_expression(&mut self) -> ParsedExpr {
         let start = self.node_start();
-        let mut lhs = match self.current_kind() {
+        let mut lhs = match self.current_token_kind() {
             TokenKind::Plus | TokenKind::Minus | TokenKind::Not | TokenKind::Tilde => {
                 Expr::UnaryOp(self.parse_unary_expression()).into()
             }
@@ -237,7 +237,7 @@ impl<'src> Parser<'src> {
     }
 
     pub(super) fn parse_identifier(&mut self) -> ast::Identifier {
-        let range = self.current_range();
+        let range = self.current_token_range();
 
         if self.at(TokenKind::Name) {
             let (Tok::Name { name }, _) = self.next_token() else {
@@ -248,7 +248,7 @@ impl<'src> Parser<'src> {
                 range,
             }
         } else {
-            if self.current_kind().is_keyword() {
+            if self.current_token_kind().is_keyword() {
                 let (tok, range) = self.next_token();
                 self.add_error(
                     ParseErrorType::OtherError(format!(
@@ -278,7 +278,7 @@ impl<'src> Parser<'src> {
     fn parse_atom(&mut self) -> ParsedExpr {
         let start = self.node_start();
 
-        let lhs = match self.current_kind() {
+        let lhs = match self.current_token_kind() {
             TokenKind::Float => {
                 let (Tok::Float { value }, _) = self.bump(TokenKind::Float) else {
                     unreachable!()
@@ -374,7 +374,7 @@ impl<'src> Parser<'src> {
                 } else {
                     self.add_error(
                         ParseErrorType::OtherError("Expression expected.".to_string()),
-                        self.current_range(),
+                        self.current_token_range(),
                     );
                     Expr::Name(ast::ExprName {
                         range: self.missing_node_range(),
@@ -390,7 +390,7 @@ impl<'src> Parser<'src> {
 
     fn parse_postfix_expression(&mut self, mut lhs: Expr, start: TextSize) -> Expr {
         loop {
-            lhs = match self.current_kind() {
+            lhs = match self.current_token_kind() {
                 TokenKind::Lpar => Expr::Call(self.parse_call_expression(lhs, start)),
                 TokenKind::Lsqb => Expr::Subscript(self.parse_subscript_expression(lhs, start)),
                 TokenKind::Dot => Expr::Attribute(self.parse_attribute_expression(lhs, start)),
@@ -401,7 +401,7 @@ impl<'src> Parser<'src> {
 
     /// See: <https://docs.python.org/3/reference/expressions.html#calls>
     fn parse_call_expression(&mut self, lhs: Expr, start: TextSize) -> ast::ExprCall {
-        assert_eq!(self.current_kind(), TokenKind::Lpar);
+        assert_eq!(self.current_token_kind(), TokenKind::Lpar);
         let arguments = self.parse_arguments();
 
         ast::ExprCall {
@@ -444,7 +444,7 @@ impl<'src> Parser<'src> {
                     let start = parser.node_start();
                     let mut parsed_expr = parser.parse_named_expression_or_higher();
 
-                    match parser.current_kind() {
+                    match parser.current_token_kind() {
                         TokenKind::Async | TokenKind::For => {
                             parsed_expr = Expr::Generator(parser.parse_generator_expression(
                                 parsed_expr.expr,
@@ -528,7 +528,7 @@ impl<'src> Parser<'src> {
 
         // Create an error when receiving a empty slice to parse, e.g. `l[]`
         if !self.at(TokenKind::Colon) && !self.at_expr() {
-            let slice_range = TextRange::empty(self.current_range().start());
+            let slice_range = TextRange::empty(self.current_token_range().start());
             self.expect(TokenKind::Rsqb);
 
             let range = self.node_range(start);
@@ -629,9 +629,9 @@ impl<'src> Parser<'src> {
     fn parse_unary_expression(&mut self) -> ast::ExprUnaryOp {
         let start = self.node_start();
 
-        let op = UnaryOp::try_from(self.current_kind())
+        let op = UnaryOp::try_from(self.current_token_kind())
             .expect("Expected operator to be a unary operator token.");
-        self.bump(self.current_kind());
+        self.bump(self.current_token_kind());
 
         let operand = if matches!(op, UnaryOp::Not) {
             self.parse_expression_with_precedence(Precedence::Not)
@@ -681,7 +681,7 @@ impl<'src> Parser<'src> {
             let parsed_expr = self.parse_expression_with_precedence(op_bp);
             values.push(parsed_expr.expr);
 
-            if self.current_kind() != op {
+            if self.current_token_kind() != op {
                 break;
             }
 
@@ -703,7 +703,7 @@ impl<'src> Parser<'src> {
         op_bp: Precedence,
     ) -> ast::ExprCompare {
         let mut comparators = vec![];
-        let op = token_kind_to_cmp_op([op, self.current_kind()]).unwrap();
+        let op = token_kind_to_cmp_op([op, self.current_token_kind()]).unwrap();
         let mut ops = vec![op];
 
         if matches!(op, CmpOp::IsNot | CmpOp::NotIn) {
@@ -717,7 +717,7 @@ impl<'src> Parser<'src> {
             let parsed_expr = self.parse_expression_with_precedence(op_bp);
             comparators.push(parsed_expr.expr);
 
-            if let Ok(op) = token_kind_to_cmp_op([self.current_kind(), self.peek_nth(1)]) {
+            if let Ok(op) = token_kind_to_cmp_op([self.current_token_kind(), self.peek_nth(1)]) {
                 if matches!(op, CmpOp::IsNot | CmpOp::NotIn) {
                     self.next_token();
                 }
@@ -901,7 +901,7 @@ impl<'src> Parser<'src> {
         while !self.at_ts(FSTRING_END_SET) {
             progress.assert_progressing(self);
 
-            let element = match self.current_kind() {
+            let element = match self.current_token_kind() {
                 TokenKind::Lbrace => {
                     FStringElement::Expression(self.parse_fstring_expression_element())
                 }
@@ -947,7 +947,7 @@ impl<'src> Parser<'src> {
     }
 
     fn parse_fstring_expression_element(&mut self) -> ast::FStringExpressionElement {
-        let range = self.current_range();
+        let range = self.current_token_range();
 
         let has_open_brace = self.eat(TokenKind::Lbrace);
         let value = self.parse_expression();
@@ -961,7 +961,8 @@ impl<'src> Parser<'src> {
             let leading_range = range
                 .add_start("{".text_len())
                 .cover_offset(value.range().start());
-            let trailing_range = TextRange::new(value.range().end(), self.current_range().start());
+            let trailing_range =
+                TextRange::new(value.range().end(), self.current_token_range().start());
             Some(ast::DebugText {
                 leading: self.src_text(leading_range).to_string(),
                 trailing: self.src_text(trailing_range).to_string(),
@@ -999,7 +1000,7 @@ impl<'src> Parser<'src> {
             None
         };
 
-        let close_brace_range = self.current_range();
+        let close_brace_range = self.current_token_range();
         if has_open_brace && !self.eat(TokenKind::Rbrace) {
             self.add_error(
                 ParseErrorType::FStringError(FStringErrorType::UnclosedLbrace),
@@ -1026,7 +1027,7 @@ impl<'src> Parser<'src> {
         if self.at_ts(NEWLINE_EOF_SET) {
             self.add_error(
                 ParseErrorType::OtherError("missing closing bracket `]`".to_string()),
-                self.current_range(),
+                self.current_token_range(),
             );
         }
 
@@ -1041,7 +1042,7 @@ impl<'src> Parser<'src> {
 
         let parsed_expr = self.parse_named_expression_or_higher();
 
-        match self.current_kind() {
+        match self.current_token_kind() {
             TokenKind::Async | TokenKind::For => {
                 Expr::ListComp(self.parse_list_comprehension_expression(parsed_expr.expr, start))
             }
@@ -1058,7 +1059,7 @@ impl<'src> Parser<'src> {
         if self.at_ts(NEWLINE_EOF_SET) {
             self.add_error(
                 ParseErrorType::OtherError("missing closing brace `}`".to_string()),
-                self.current_range(),
+                self.current_token_range(),
             );
         }
 
@@ -1079,7 +1080,7 @@ impl<'src> Parser<'src> {
 
         let key_or_value = self.parse_named_expression_or_higher();
 
-        match self.current_kind() {
+        match self.current_token_kind() {
             TokenKind::Async | TokenKind::For => {
                 Expr::SetComp(self.parse_set_comprehension_expression(key_or_value.expr, start))
             }
@@ -1087,7 +1088,7 @@ impl<'src> Parser<'src> {
                 self.bump(TokenKind::Colon);
                 let value = self.parse_conditional_expression_or_higher();
 
-                if matches!(self.current_kind(), TokenKind::Async | TokenKind::For) {
+                if matches!(self.current_token_kind(), TokenKind::Async | TokenKind::For) {
                     Expr::DictComp(self.parse_dictionary_comprehension_expression(
                         key_or_value.expr,
                         value.expr,
@@ -1114,7 +1115,7 @@ impl<'src> Parser<'src> {
 
         // Nice error message when having a unclosed open parenthesis `(`
         if self.at_ts(NEWLINE_EOF_SET) {
-            let range = self.current_range();
+            let range = self.current_token_range();
             self.add_error(
                 ParseErrorType::OtherError("missing closing parenthesis `)`".to_string()),
                 range,
@@ -1136,7 +1137,7 @@ impl<'src> Parser<'src> {
 
         let mut parsed_expr = self.parse_named_expression_or_higher();
 
-        let parsed = match self.current_kind() {
+        let parsed = match self.current_token_kind() {
             TokenKind::Comma => {
                 let tuple = self.parse_tuple_expression(
                     parsed_expr.expr,
@@ -1523,19 +1524,19 @@ impl<'src> Parser<'src> {
         self.expect(TokenKind::Colon);
 
         // Check for forbidden tokens in the `lambda`'s body
-        match self.current_kind() {
+        match self.current_token_kind() {
             TokenKind::Yield => self.add_error(
                 ParseErrorType::OtherError(
                     "`yield` not allowed in a `lambda` expression".to_string(),
                 ),
-                self.current_range(),
+                self.current_token_range(),
             ),
             TokenKind::Star => {
                 self.add_error(
                     ParseErrorType::OtherError(
                         "starred expression not allowed in a `lambda` expression".to_string(),
                     ),
-                    self.current_range(),
+                    self.current_token_range(),
                 );
             }
             TokenKind::DoubleStar => {
@@ -1544,7 +1545,7 @@ impl<'src> Parser<'src> {
                         "double starred expression not allowed in a `lambda` expression"
                             .to_string(),
                     ),
-                    self.current_range(),
+                    self.current_token_range(),
                 );
             }
             _ => {}
diff --git a/crates/ruff_python_parser/src/parser/mod.rs b/crates/ruff_python_parser/src/parser/mod.rs
index 49b1831dfe..2d1e387f93 100644
--- a/crates/ruff_python_parser/src/parser/mod.rs
+++ b/crates/ruff_python_parser/src/parser/mod.rs
@@ -211,7 +211,7 @@ impl<'src> Parser<'src> {
         // If it's not, you probably forgot to call `clear_ctx` somewhere.
         assert_eq!(self.ctx, ParserCtxFlags::empty());
         assert_eq!(
-            self.current_kind(),
+            self.current_token_kind(),
             TokenKind::EndOfFile,
             "Parser should be at the end of the file."
         );
@@ -279,7 +279,7 @@ impl<'src> Parser<'src> {
 
     /// Returns the start position for a node that starts at the current token.
     fn node_start(&self) -> TextSize {
-        self.current_range().start()
+        self.current_token_range().start()
     }
 
     fn node_range(&self, start: TextSize) -> TextRange {
@@ -326,7 +326,7 @@ impl<'src> Parser<'src> {
 
     fn peek_nth(&self, offset: usize) -> TokenKind {
         if offset == 0 {
-            self.current_kind()
+            self.current_token_kind()
         } else {
             self.tokens
                 .peek_nth(offset - 1)
@@ -334,40 +334,50 @@ impl<'src> Parser<'src> {
         }
     }
 
+    /// Returns the current token kind along with its range.
+    ///
+    /// Use `current_token_kind` or `current_token_range` to only get the kind or range
+    /// respectively.
     #[inline]
     fn current_token(&self) -> (TokenKind, TextRange) {
-        (self.current_kind(), self.current_range())
+        (self.current_token_kind(), self.current_token_range())
     }
 
+    /// Returns the current token kind.
     #[inline]
-    fn current_kind(&self) -> TokenKind {
+    fn current_token_kind(&self) -> TokenKind {
         // TODO: Converting the token kind over and over again can be expensive.
         TokenKind::from_token(&self.current.0)
     }
 
+    /// Returns the range of the current token.
     #[inline]
-    fn current_range(&self) -> TextRange {
+    fn current_token_range(&self) -> TextRange {
         self.current.1
     }
 
+    /// Eat the current token if it is of the given kind, returning `true` in
+    /// that case. Otherwise, return `false`.
     fn eat(&mut self, kind: TokenKind) -> bool {
-        if !self.at(kind) {
-            return false;
+        if self.at(kind) {
+            self.next_token();
+            true
+        } else {
+            false
         }
-
-        self.next_token();
-        true
     }
 
     /// Bumps the current token assuming it is of the given kind.
     ///
     /// # Panics
+    ///
     /// If the current token is not of the given kind.
     ///
     /// # Returns
+    ///
     /// The current token
     fn bump(&mut self, kind: TokenKind) -> (Tok, TextRange) {
-        assert_eq!(self.current_kind(), kind);
+        assert_eq!(self.current_token_kind(), kind);
 
         self.next_token()
     }
@@ -382,7 +392,7 @@ impl<'src> Parser<'src> {
     ///
     /// The current token.
     fn bump_ts(&mut self, ts: TokenSet) -> (Tok, TextRange) {
-        assert!(ts.contains(self.current_kind()));
+        assert!(ts.contains(self.current_token_kind()));
 
         self.next_token()
     }
@@ -430,11 +440,11 @@ impl<'src> Parser<'src> {
     }
 
     fn at(&self, kind: TokenKind) -> bool {
-        self.current_kind() == kind
+        self.current_token_kind() == kind
     }
 
     fn at_ts(&self, ts: TokenSet) -> bool {
-        ts.contains(self.current_kind())
+        ts.contains(self.current_token_kind())
     }
 
     fn src_text<T>(&self, ranged: T) -> &'src str
@@ -487,7 +497,7 @@ impl<'src> Parser<'src> {
                 // Not a recognised element. Add an error and either skip the token or break parsing the list
                 // if the token is recognised as an element or terminator of an enclosing list.
                 let error = kind.create_error(self);
-                self.add_error(error, self.current_range());
+                self.add_error(error, self.current_token_range());
 
                 if should_recover {
                     break;
@@ -518,12 +528,12 @@ impl<'src> Parser<'src> {
         loop {
             progress.assert_progressing(self);
 
-            self.current_kind();
+            self.current_token_kind();
 
             if kind.is_list_element(self) {
                 elements.push(parse_element(self));
 
-                let maybe_comma_range = self.current_range();
+                let maybe_comma_range = self.current_token_range();
                 if self.eat(TokenKind::Comma) {
                     trailing_comma_range = Some(maybe_comma_range);
                     continue;
@@ -544,14 +554,14 @@ impl<'src> Parser<'src> {
                 // Not a recognised element. Add an error and either skip the token or break parsing the list
                 // if the token is recognised as an element or terminator of an enclosing list.
                 let error = kind.create_error(self);
-                self.add_error(error, self.current_range());
+                self.add_error(error, self.current_token_range());
 
                 if should_recover {
                     break;
                 }
 
                 if self.at(TokenKind::Comma) {
-                    trailing_comma_range = Some(self.current_range());
+                    trailing_comma_range = Some(self.current_token_range());
                 } else {
                     trailing_comma_range = None;
                 }
@@ -640,7 +650,7 @@ impl<'src> Parser<'src> {
 
     fn is_current_token_postfix(&self) -> bool {
         matches!(
-            self.current_kind(),
+            self.current_token_kind(),
             TokenKind::Lpar | TokenKind::Lsqb | TokenKind::Dot
         )
     }
@@ -712,19 +722,19 @@ impl RecoveryContextKind {
 
             RecoveryContextKind::Elif => p.at(TokenKind::Else),
             RecoveryContextKind::Except => {
-                matches!(p.current_kind(), TokenKind::Finally | TokenKind::Else)
+                matches!(p.current_token_kind(), TokenKind::Finally | TokenKind::Else)
             }
 
             // TODO: Should `semi` be part of the simple statement recovery set instead?
             RecoveryContextKind::AssignmentTargets => {
-                matches!(p.current_kind(), TokenKind::Newline | TokenKind::Semi)
+                matches!(p.current_token_kind(), TokenKind::Newline | TokenKind::Semi)
             }
 
             // Tokens other than `]` are for better error recovery: For example, recover when we find the `:` of a clause header or
             // the equal of a type assignment.
             RecoveryContextKind::TypeParams => {
                 matches!(
-                    p.current_kind(),
+                    p.current_token_kind(),
                     TokenKind::Rsqb
                         | TokenKind::Newline
                         | TokenKind::Colon
@@ -733,7 +743,7 @@ impl RecoveryContextKind {
                 )
             }
             RecoveryContextKind::ImportNames => {
-                matches!(p.current_kind(), TokenKind::Rpar | TokenKind::Newline)
+                matches!(p.current_token_kind(), TokenKind::Rpar | TokenKind::Newline)
             }
         }
     }
@@ -747,7 +757,7 @@ impl RecoveryContextKind {
             RecoveryContextKind::AssignmentTargets => p.at(TokenKind::Equal),
             RecoveryContextKind::TypeParams => p.is_at_type_param(),
             RecoveryContextKind::ImportNames => {
-                matches!(p.current_kind(), TokenKind::Star | TokenKind::Name)
+                matches!(p.current_token_kind(), TokenKind::Star | TokenKind::Name)
             }
         }
     }
@@ -770,7 +780,7 @@ impl RecoveryContextKind {
                     .to_string(),
             ),
             RecoveryContextKind::AssignmentTargets => {
-                if p.current_kind().is_keyword() {
+                if p.current_token_kind().is_keyword() {
                     ParseErrorType::OtherError(
                         "The keyword is not allowed as a variable declaration name".to_string(),
                     )
diff --git a/crates/ruff_python_parser/src/parser/pattern.rs b/crates/ruff_python_parser/src/parser/pattern.rs
index 0d3ef8e059..2e9b3e386a 100644
--- a/crates/ruff_python_parser/src/parser/pattern.rs
+++ b/crates/ruff_python_parser/src/parser/pattern.rs
@@ -74,7 +74,7 @@ impl<'src> Parser<'src> {
 
     fn parse_match_pattern_lhs(&mut self) -> Pattern {
         let start = self.node_start();
-        let mut lhs = match self.current_kind() {
+        let mut lhs = match self.current_token_kind() {
             TokenKind::Lbrace => Pattern::MatchMapping(self.parse_match_pattern_mapping()),
             TokenKind::Star => Pattern::MatchStar(self.parse_match_pattern_star()),
             TokenKind::Lpar | TokenKind::Lsqb => self.parse_delimited_match_pattern(),
@@ -261,13 +261,16 @@ impl<'src> Parser<'src> {
             SequenceMatchPatternParentheses::List
         };
 
-        if matches!(self.current_kind(), TokenKind::Newline | TokenKind::Colon) {
+        if matches!(
+            self.current_token_kind(),
+            TokenKind::Newline | TokenKind::Colon
+        ) {
             self.add_error(
                 ParseErrorType::OtherError(format!(
                     "missing `{closing}`",
                     closing = if parentheses.is_list() { "]" } else { ")" }
                 )),
-                self.current_range(),
+                self.current_token_range(),
             );
         }
 
@@ -330,7 +333,7 @@ impl<'src> Parser<'src> {
 
     fn parse_match_pattern_literal(&mut self) -> Pattern {
         let start = self.node_start();
-        match self.current_kind() {
+        match self.current_token_kind() {
             TokenKind::None => {
                 self.bump(TokenKind::None);
                 Pattern::MatchSingleton(ast::PatternMatchSingleton {
@@ -460,7 +463,7 @@ impl<'src> Parser<'src> {
                 } else {
                     self.add_error(
                         ParseErrorType::OtherError("Expression expected.".to_string()),
-                        self.current_range(),
+                        self.current_token_range(),
                     );
                     Expr::Name(ast::ExprName {
                         range: self.missing_node_range(),
@@ -478,7 +481,7 @@ impl<'src> Parser<'src> {
     }
 
     fn parse_attr_expr_for_match_pattern(&mut self, mut lhs: Expr, start: TextSize) -> Expr {
-        while self.current_kind() == TokenKind::Dot {
+        while self.current_token_kind() == TokenKind::Dot {
             lhs = Expr::Attribute(self.parse_attribute_expression(lhs, start));
         }
 
diff --git a/crates/ruff_python_parser/src/parser/progress.rs b/crates/ruff_python_parser/src/parser/progress.rs
index 919565cde2..d21eba1504 100644
--- a/crates/ruff_python_parser/src/parser/progress.rs
+++ b/crates/ruff_python_parser/src/parser/progress.rs
@@ -12,7 +12,7 @@ impl ParserProgress {
     fn has_progressed(self, p: &Parser) -> bool {
         match self.0 {
             None => true,
-            Some(snapshot) => snapshot != (p.current_kind(), p.current_range().start()),
+            Some(snapshot) => snapshot != (p.current_token_kind(), p.current_token_range().start()),
         }
     }
 
@@ -26,11 +26,11 @@ impl ParserProgress {
         assert!(
             self.has_progressed(p),
             "The parser is no longer progressing. Stuck at '{}' {:?}:{:?}",
-            p.src_text(p.current_range()),
-            p.current_kind(),
-            p.current_range(),
+            p.src_text(p.current_token_range()),
+            p.current_token_kind(),
+            p.current_token_range(),
         );
 
-        self.0 = Some((p.current_kind(), p.current_range().start()));
+        self.0 = Some((p.current_token_kind(), p.current_token_range().start()));
     }
 }
diff --git a/crates/ruff_python_parser/src/parser/statement.rs b/crates/ruff_python_parser/src/parser/statement.rs
index 16a905a6fb..9bb3068b79 100644
--- a/crates/ruff_python_parser/src/parser/statement.rs
+++ b/crates/ruff_python_parser/src/parser/statement.rs
@@ -85,7 +85,7 @@ impl<'src> Parser<'src> {
     /// Parses a compound or a simple statement.
     pub(super) fn parse_statement(&mut self) -> Stmt {
         let start_offset = self.node_start();
-        match self.current_kind() {
+        match self.current_token_kind() {
             TokenKind::If => Stmt::If(self.parse_if_statement()),
             TokenKind::For => Stmt::For(self.parse_for_statement(start_offset)),
             TokenKind::While => Stmt::While(self.parse_while_statement()),
@@ -113,7 +113,7 @@ impl<'src> Parser<'src> {
         let has_eaten_newline = self.eat(TokenKind::Newline);
 
         if !has_eaten_newline && !has_eaten_semicolon && self.at_simple_stmt() {
-            let range = self.current_range();
+            let range = self.current_token_range();
             self.add_error(
                 ParseErrorType::SimpleStmtsInSameLine,
                 stmt.range().cover(range),
@@ -136,7 +136,7 @@ impl<'src> Parser<'src> {
 
             self.add_error(
                 ParseErrorType::SimpleStmtAndCompoundStmtInSameLine,
-                stmt.range().cover(self.current_range()),
+                stmt.range().cover(self.current_token_range()),
             );
         }
 
@@ -179,7 +179,7 @@ impl<'src> Parser<'src> {
 
     /// See: <https://docs.python.org/3/reference/simple_stmts.html#simple-statements>
     fn parse_simple_statement(&mut self) -> Stmt {
-        match self.current_kind() {
+        match self.current_token_kind() {
             TokenKind::Return => Stmt::Return(self.parse_return_statement()),
             TokenKind::Import => Stmt::Import(self.parse_import_statement()),
             TokenKind::From => Stmt::ImportFrom(self.parse_from_import_statement()),
@@ -203,7 +203,7 @@ impl<'src> Parser<'src> {
                     Stmt::Assign(self.parse_assign_statement(parsed_expr, start))
                 } else if self.eat(TokenKind::Colon) {
                     Stmt::AnnAssign(self.parse_annotated_assignment_statement(parsed_expr, start))
-                } else if let Ok(op) = Operator::try_from(self.current_kind()) {
+                } else if let Ok(op) = Operator::try_from(self.current_token_kind()) {
                     Stmt::AugAssign(self.parse_augmented_assignment_statement(
                         parsed_expr,
                         op,
@@ -381,7 +381,7 @@ impl<'src> Parser<'src> {
         };
 
         if level == 0 && module.is_none() {
-            let range = self.current_range();
+            let range = self.current_token_range();
             self.add_error(
                 ParseErrorType::OtherError("missing module name".to_string()),
                 range,
@@ -777,7 +777,7 @@ impl<'src> Parser<'src> {
         };
 
         if !has_except && !has_finally {
-            let range = self.current_range();
+            let range = self.current_token_range();
             self.add_error(
                 ParseErrorType::OtherError(
                     "expecting `except` or `finally` after `try` block".to_string(),
@@ -952,7 +952,7 @@ impl<'src> Parser<'src> {
         let mut items = vec![];
 
         if !self.at_expr() {
-            let range = self.current_range();
+            let range = self.current_token_range();
             self.add_error(
                 ParseErrorType::OtherError("expecting expression after `with` keyword".to_string()),
                 range,
@@ -996,7 +996,7 @@ impl<'src> Parser<'src> {
             let mut has_seen_rpar = false;
             let mut has_seen_colon_equal = false;
             let mut has_seen_star = false;
-            let mut prev_token = self.current_kind();
+            let mut prev_token = self.current_token_kind();
             loop {
                 match self.peek_nth(index) {
                     TokenKind::Lpar => {
@@ -1170,7 +1170,7 @@ impl<'src> Parser<'src> {
 
         self.eat(TokenKind::Newline);
         if !self.eat(TokenKind::Indent) {
-            let range = self.current_range();
+            let range = self.current_token_range();
             self.add_error(
                 ParseErrorType::OtherError(
                     "expected an indented block after `match` statement".to_string(),
@@ -1194,7 +1194,7 @@ impl<'src> Parser<'src> {
         if !self.at(TokenKind::Case) {
             self.add_error(
                 ParseErrorType::OtherError("expecting `case` block after `match`".to_string()),
-                self.current_range(),
+                self.current_token_range(),
             );
         }
 
@@ -1239,7 +1239,7 @@ impl<'src> Parser<'src> {
         let async_start = self.node_start();
         self.bump(TokenKind::Async);
 
-        match self.current_kind() {
+        match self.current_token_kind() {
             TokenKind::Def => Stmt::FunctionDef(ast::StmtFunctionDef {
                 is_async: true,
                 ..self.parse_function_definition(vec![], async_start)
@@ -1255,7 +1255,10 @@ impl<'src> Parser<'src> {
             kind => {
                 // Although this statement is not a valid `async` statement,
                 // we still parse it.
-                self.add_error(ParseErrorType::StmtIsNotAsync(kind), self.current_range());
+                self.add_error(
+                    ParseErrorType::StmtIsNotAsync(kind),
+                    self.current_token_range(),
+                );
                 self.parse_statement()
             }
         }
@@ -1281,7 +1284,7 @@ impl<'src> Parser<'src> {
             self.expect(TokenKind::Newline);
         }
 
-        match self.current_kind() {
+        match self.current_token_kind() {
             TokenKind::Def => {
                 Stmt::FunctionDef(self.parse_function_definition(decorators, start_offset))
             }
@@ -1301,7 +1304,7 @@ impl<'src> Parser<'src> {
                     ParseErrorType::OtherError(
                         "expected class, function definition or async function definition after decorator".to_string(),
                     ),
-                    self.current_range(),
+                    self.current_token_range(),
                 );
                 self.parse_statement()
             }
@@ -1323,7 +1326,7 @@ impl<'src> Parser<'src> {
             ParseErrorType::OtherError(format!(
                 "expected a single statement or an indented body after {parent_clause}"
             )),
-            self.current_range(),
+            self.current_token_range(),
         );
 
         Vec::new()
@@ -1402,7 +1405,7 @@ impl<'src> Parser<'src> {
             if has_seen_vararg {
                 parser.add_error(
                     ParseErrorType::ParamFollowsVarKeywordParam,
-                    parser.current_range(),
+                    parser.current_token_range(),
                 );
             }
 
@@ -1423,7 +1426,7 @@ impl<'src> Parser<'src> {
                 if has_seen_asterisk {
                     parser.add_error(
                         ParseErrorType::OtherError("`/` must be ahead of `*`".to_string()),
-                        parser.current_range(),
+                        parser.current_token_range(),
                     );
                 }
                 std::mem::swap(&mut args, &mut posonlyargs);
@@ -1433,7 +1436,10 @@ impl<'src> Parser<'src> {
                 // can't place `b` after `a=1`. Non-default parameters are only allowed after
                 // default parameters if we have a `*` before them, e.g. `a=1, *, b`.
                 if param.default.is_none() && has_seen_default_param && !has_seen_asterisk {
-                    parser.add_error(ParseErrorType::DefaultArgumentError, parser.current_range());
+                    parser.add_error(
+                        ParseErrorType::DefaultArgumentError,
+                        parser.current_token_range(),
+                    );
                 }
                 has_seen_default_param = param.default.is_some();
 
@@ -1447,14 +1453,14 @@ impl<'src> Parser<'src> {
                     return;
                 }
 
-                let range = parser.current_range();
+                let range = parser.current_token_range();
                 #[allow(deprecated)]
                 parser.skip_until(
                     ending_set.union(TokenSet::new([TokenKind::Comma, TokenKind::Colon])),
                 );
                 parser.add_error(
                     ParseErrorType::OtherError("expected parameter".to_string()),
-                    range.cover(parser.current_range()), // TODO(micha): This goes one token too far?
+                    range.cover(parser.current_token_range()), // TODO(micha): This goes one token too far?
                 );
             }
         });
@@ -1500,9 +1506,9 @@ impl<'src> Parser<'src> {
 
     pub(super) fn is_at_type_param(&self) -> bool {
         matches!(
-            self.current_kind(),
+            self.current_token_kind(),
             TokenKind::Star | TokenKind::DoubleStar | TokenKind::Name
-        ) || self.current_kind().is_keyword()
+        ) || self.current_token_kind().is_keyword()
     }
 
     fn parse_type_param(&mut self) -> ast::TypeParam {