refactor(estree/tokens): make Context methods take AST nodes

overlookmotel · overlookmotel · commit c919ce92c0bc · 2026-03-01T09:44:13.000Z
diff --git a/crates/oxc_estree_tokens/src/context.rs b/crates/oxc_estree_tokens/src/context.rs
@@ -1,8 +1,8 @@
 //! [`Context`] trait.
 
-use oxc_ast::ast::{RegExpLiteral, TemplateElement};
+use oxc_ast::ast::{JSXText, PrivateIdentifier, RegExpLiteral, StringLiteral, TemplateElement};
 
-use crate::{jsx_state::JSXState, token_type::TokenType, visitor::Visitor};
+use crate::{jsx_state::JSXState, visitor::Visitor};
 
 /// Trait abstracting over the two token processing modes:
 /// JSON serialization ([`JsonContext`]) and raw transfer ([`RawContext`]).
@@ -51,29 +51,31 @@ pub trait Context: Sized {
     /// * Raw transfer mode: Set kind to `Kind::JSXIdentifier`.
     fn emit_jsx_identifier_at(&mut self, start: u32, name: &str);
 
-    /// Emit the token at `start` as `PrivateIdentifier`.
+    /// Emit a `PrivateIdentifier` token.
     ///
     /// * JSON mode: Serialize with appropriate encoding.
     /// * Raw transfer mode: No-op (token already has `Kind::PrivateIdentifier`).
-    fn emit_private_identifier_at(&mut self, start: u32, name: &str);
+    fn emit_private_identifier(&mut self, ident: &PrivateIdentifier<'_>);
+
+    /// Emit a `StringLiteral` token.
+    ///
+    /// * JSON mode: Serialize with JSON encoding (`value` may not be JSON-safe).
+    /// * Raw transfer mode: No-op (token already has the correct kind).
+    fn emit_string_literal(&mut self, literal: &StringLiteral<'_>);
 
     /// Emit a `StringLiteral` in a JSX attribute as `JSXText`.
     ///
-    /// Unlike [`emit_unsafe_token_at`], this changes the token's kind in raw transfer mode,
-    /// because the token has `Kind::Str` but needs to become `Kind::JSXText`.
-    /// Use [`emit_unsafe_token_at`] for actual `JSXText` tokens which already have the correct kind.
+    /// The token has `Kind::Str` but needs to become `JSXText`.
     ///
     /// * JSON mode: Serialize as `JSXText` with JSON encoding.
     /// * Raw transfer mode: Set kind to `Kind::JSXText`.
-    ///
-    /// [`emit_unsafe_token_at`]: Context::emit_unsafe_token_at
-    fn emit_jsx_text_at(&mut self, start: u32);
+    fn emit_string_literal_as_jsx_text(&mut self, literal: &StringLiteral<'_>);
 
-    /// Emit a token whose value may not be JSON-safe (strings, templates, JSXText).
+    /// Emit a `JSXText` token whose value may not be JSON-safe.
     ///
     /// * JSON mode: Serialize with JSON encoding.
-    /// * Raw transfer mode: No-op (token already has the correct kind).
-    fn emit_unsafe_token_at(&mut self, start: u32, token_type: TokenType);
+    /// * Raw transfer mode: No-op (token already has `Kind::JSXText`).
+    fn emit_jsx_text(&mut self, jsx_text: &JSXText<'_>);
 
     /// Emit a `RegularExpression` token.
     ///
diff --git a/crates/oxc_estree_tokens/src/json.rs b/crates/oxc_estree_tokens/src/json.rs
@@ -2,7 +2,9 @@
 
 use std::slice::Iter;
 
-use oxc_ast::ast::{Program, RegExpLiteral, TemplateElement};
+use oxc_ast::ast::{
+    JSXText, PrivateIdentifier, Program, RegExpLiteral, StringLiteral, TemplateElement,
+};
 use oxc_ast_visit::utf8_to_utf16::Utf8ToUtf16;
 use oxc_ast_visit::{Visit, utf8_to_utf16::Utf8ToUtf16Converter};
 use oxc_estree::{
@@ -241,11 +243,18 @@ impl<'b, O: ESTreeTokenConfig, S: SequenceSerializer> JsonContext<'b, O, S> {
         self.serialize_safe_token(token, token_type, value);
     }
 
+    /// Advance to the token at `start` and serialize it using provided `value` without JSON encoding.
     fn emit_safe_token_at(&mut self, start: u32, token_type: TokenType, value: &str) {
         let token = self.advance_to(start);
         self.serialize_safe_token(token, token_type, value);
     }
 
+    /// Advance to the token at `start` and serialize it using raw source text with JSON encoding.
+    fn emit_unsafe_token_at(&mut self, start: u32, token_type: TokenType) {
+        let token = self.advance_to(start);
+        self.emit_unsafe_token(token, token_type);
+    }
+
     /// Serialize a token using its raw source text, with JSON encoding.
     ///
     /// Used for tokens whose values may contain backslashes, quotes, or control characters
@@ -365,19 +374,19 @@ impl<O: ESTreeTokenConfig, S: SequenceSerializer> Context for JsonContext<'_, O,
         self.emit_safe_token_at(start, TokenType::new("JSXIdentifier"), name);
     }
 
-    /// Emit the token at `start` as `PrivateIdentifier`.
-    fn emit_private_identifier_at(&mut self, start: u32, name: &str) {
-        let token = self.advance_to(start);
+    /// Emit a `PrivateIdentifier` token.
+    fn emit_private_identifier(&mut self, ident: &PrivateIdentifier<'_>) {
+        let token = self.advance_to(ident.span.start);
 
-        // `identifier.name` has `#` stripped and escapes decoded by the parser, and is JSON-safe.
+        // `ident.name` has `#` stripped and escapes decoded by the parser, and is JSON-safe.
         // Use it in most cases — if token is not marked as escaped, it's JSON-safe, so can skip JSON encoding.
         // When `self.is_js()` is `true`, token `value` should *always* be the unescaped version,
         // so can also use `name` from AST node and skip JSON encoding.
         // Only fall back to raw source text when the token contains escapes *and* decoding is disabled,
         // since escape sequences contain `\` which needs JSON escaping.
         // Escaped identifiers are extremely rare, so handle them in `#[cold]` branch.
         if self.is_js() || !token.escaped() {
-            self.serialize_safe_token(token, TokenType::new("PrivateIdentifier"), name);
+            self.serialize_safe_token(token, TokenType::new("PrivateIdentifier"), &ident.name);
         } else {
             #[cold]
             #[inline(never)]
@@ -393,17 +402,19 @@ impl<O: ESTreeTokenConfig, S: SequenceSerializer> Context for JsonContext<'_, O,
         }
     }
 
-    /// Emit the token at `start` as `JSXText`.
-    fn emit_jsx_text_at(&mut self, start: u32) {
-        let token = self.advance_to(start);
-        self.emit_unsafe_token(token, TokenType::new("JSXText"));
+    /// Emit a `StringLiteral` token.
+    fn emit_string_literal(&mut self, literal: &StringLiteral<'_>) {
+        self.emit_unsafe_token_at(literal.span.start, TokenType::new("String"));
     }
 
-    /// Emit the token at `start` as the specified token type,
-    /// where the token's `value` may not be JSON-safe.
-    fn emit_unsafe_token_at(&mut self, start: u32, token_type: TokenType) {
-        let token = self.advance_to(start);
-        self.emit_unsafe_token(token, token_type);
+    /// Emit a `StringLiteral` in a JSX attribute as `JSXText`.
+    fn emit_string_literal_as_jsx_text(&mut self, literal: &StringLiteral<'_>) {
+        self.emit_unsafe_token_at(literal.span.start, TokenType::new("JSXText"));
+    }
+
+    /// Emit a `JSXText` token.
+    fn emit_jsx_text(&mut self, jsx_text: &JSXText<'_>) {
+        self.emit_unsafe_token_at(jsx_text.span.start, TokenType::new("JSXText"));
     }
 
     /// Emit token for `RegExpLiteral`.
diff --git a/crates/oxc_estree_tokens/src/raw_transfer.rs b/crates/oxc_estree_tokens/src/raw_transfer.rs
@@ -2,16 +2,16 @@
 
 use std::slice::IterMut;
 
-use oxc_ast::ast::{Program, RegExpLiteral, TemplateElement};
+use oxc_ast::ast::{
+    JSXText, PrivateIdentifier, Program, RegExpLiteral, StringLiteral, TemplateElement,
+};
 use oxc_ast_visit::{
     Visit,
     utf8_to_utf16::{Utf8ToUtf16, Utf8ToUtf16Converter},
 };
 use oxc_parser::{Kind, Token};
 
-use crate::{
-    context::Context, options::ESTreeTokenConfig, token_type::TokenType, visitor::Visitor,
-};
+use crate::{context::Context, options::ESTreeTokenConfig, visitor::Visitor};
 
 /// Walk AST and set token kinds to match ESTree token types.
 /// Convert token spans from UTF-8 byte offsets to UTF-16 offsets.
@@ -147,26 +147,39 @@ impl<O: ESTreeTokenConfig> Context for RawContext<'_, O> {
         token.set_kind(Kind::JSXIdentifier);
     }
 
-    /// Handle `PrivateIdentifier` token at `start` (no-op).
+    /// Handle `PrivateIdentifier` token (no-op).
     #[inline(always)]
-    fn emit_private_identifier_at(&mut self, _start: u32, _name: &str) {
+    fn emit_private_identifier(&mut self, _ident: &PrivateIdentifier<'_>) {
         // No-op: token already has `Kind::PrivateIdentifier`.
         // The iterator will skip past this token on the next `advance_to` call.
     }
 
-    /// Set `Kind` of the token at `start` to `JSXText`.
-    fn emit_jsx_text_at(&mut self, start: u32) {
-        let token = self.advance_to(start);
+    /// Handle `StringLiteral` token (no-op).
+    #[inline(always)]
+    fn emit_string_literal(&mut self, _literal: &StringLiteral<'_>) {
+        // No-op: token already has `Kind::Str`.
+        // The iterator will skip past this token on the next `advance_to` call.
+    }
+
+    /// Set `Kind` of the `StringLiteral` token to `JSXText`.
+    fn emit_string_literal_as_jsx_text(&mut self, literal: &StringLiteral<'_>) {
+        let token = self.advance_to(literal.span.start);
         token.set_kind(Kind::JSXText);
     }
 
-    /// Handle token at `start` (no-op).
+    /// Handle `JSXText` token (no-op).
     #[inline(always)]
-    fn emit_unsafe_token_at(&mut self, _start: u32, _token_type: TokenType) {}
+    fn emit_jsx_text(&mut self, _jsx_text: &JSXText<'_>) {
+        // No-op: token already has `Kind::JSXText`.
+        // The iterator will skip past this token on the next `advance_to` call.
+    }
 
     /// Handle `RegExpLiteral` (no-op).
     #[inline(always)]
-    fn emit_regexp(&mut self, _regexp: &RegExpLiteral<'_>) {}
+    fn emit_regexp(&mut self, _regexp: &RegExpLiteral<'_>) {
+        // No-op: token already has `Kind::RegExp`.
+        // The iterator will skip past this token on the next `advance_to` call.
+    }
 
     /// Walk template interpolations (expressions or TS types).
     fn walk_template_quasis_interleaved<I>(
diff --git a/crates/oxc_estree_tokens/src/visitor.rs b/crates/oxc_estree_tokens/src/visitor.rs
@@ -6,7 +6,7 @@ use oxc_ast::ast::*;
 use oxc_ast_visit::{Visit, walk};
 use oxc_span::GetSpan;
 
-use crate::{context::Context, jsx_state::JSXState, token_type::TokenType};
+use crate::{context::Context, jsx_state::JSXState};
 
 /// Visitor that walks the AST and delegates token processing to a [`Context`].
 ///
@@ -121,7 +121,7 @@ impl<'a, C: Context> Visit<'a> for Visitor<C> {
     }
 
     fn visit_private_identifier(&mut self, identifier: &PrivateIdentifier<'a>) {
-        self.ctx.emit_private_identifier_at(identifier.span.start, &identifier.name);
+        self.ctx.emit_private_identifier(identifier);
     }
 
     fn visit_reg_exp_literal(&mut self, regexp: &RegExpLiteral<'a>) {
@@ -229,14 +229,13 @@ impl<'a, C: Context> Visit<'a> for Visitor<C> {
     }
 
     fn visit_string_literal(&mut self, literal: &StringLiteral<'a>) {
-        // No-op in raw transfer mode - token's `Kind` is already `String`
-        self.ctx.emit_unsafe_token_at(literal.span.start, TokenType::new("String"));
+        // No-op in raw transfer mode - token already has `Kind::Str`
+        self.ctx.emit_string_literal(literal);
     }
 
-    fn visit_jsx_text(&mut self, text: &JSXText<'a>) {
-        // Use `emit_unsafe_token_at` not `emit_jsx_text_at`, as the token's `Kind` is already `JSXText`,
-        // so no-op in raw transfer mode
-        self.ctx.emit_unsafe_token_at(text.span.start, TokenType::new("JSXText"));
+    fn visit_jsx_text(&mut self, jsx_text: &JSXText<'a>) {
+        // No-op in raw transfer mode - token's `Kind` is already `JSXText`
+        self.ctx.emit_jsx_text(jsx_text);
     }
 
     fn visit_jsx_attribute(&mut self, attribute: &JSXAttribute<'a>) {
@@ -246,9 +245,8 @@ impl<'a, C: Context> Visit<'a> for Visitor<C> {
         self.visit_jsx_attribute_name(&attribute.name);
         match &attribute.value {
             Some(JSXAttributeValue::StringLiteral(string_literal)) => {
-                // Use `emit_jsx_text_at` not `emit_unsafe_token_at`, as the token `Kind`
-                // needs to be set to `JSXText` in raw transfer mode
-                self.ctx.emit_jsx_text_at(string_literal.span.start);
+                // Token `Kind` needs to be set to `JSXText` in raw transfer mode
+                self.ctx.emit_string_literal_as_jsx_text(string_literal);
             }
             Some(value) => self.visit_jsx_attribute_value(value),
             None => {}
