fix(ast/estree): fix span for TemplateElement in TS AST

crates/oxc_ast/src/ast/js.rs

@@ -462,9 +462,9 @@ pub struct TaggedTemplateExpression<'a> {
 #[ast(visit)]
 #[derive(Debug, Clone)]
 #[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree)]
+#[estree(via = TemplateElementConverter)]
 pub struct TemplateElement<'a> {
     pub span: Span,
-    #[estree(via = TemplateElementValue)]
     pub value: TemplateElementValue<'a>,
     pub tail: bool,
     /// The template element contains lone surrogates.

crates/oxc_ast/src/generated/derive_estree.rs

@@ -331,13 +331,7 @@ impl ESTree for TaggedTemplateExpression<'_> {
 
 impl ESTree for TemplateElement<'_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
-        let mut state = serializer.serialize_struct();
-        state.serialize_field("type", &JsonSafeString("TemplateElement"));
-        state.serialize_field("start", &self.span.start);
-        state.serialize_field("end", &self.span.end);
-        state.serialize_field("value", &crate::serialize::TemplateElementValue(self));
-        state.serialize_field("tail", &self.tail);
-        state.end();
+        crate::serialize::TemplateElementConverter(self).serialize(serializer)
     }
 }
 

crates/oxc_ast/src/serialize.rs

@@ -417,20 +417,61 @@ impl ESTree for RegExpFlagsConverter<'_> {
     }
 }
 
+/// Converter for `TemplateElement`.
+///
+/// Decode `cooked` if it contains lone surrogates.
+///
+/// Also adjust span in TS AST.
+/// TS-ESLint produces a different span from Acorn:
+/// ```js
+/// const template = `abc${x}def${x}ghi`;
+/// // Acorn:         ^^^    ^^^    ^^^
+/// // TS-ESLint:    ^^^^^^ ^^^^^^ ^^^^^
+/// ```
+// TODO: Raise an issue on TS-ESLint and see if they'll change span to match Acorn.
+#[ast_meta]
+#[estree(raw_deser = r#"
+    const tail = DESER[bool](POS_OFFSET.tail),
+        start = DESER[u32](POS_OFFSET.span.start) /* IF_TS */ - 1 /* END_IF_TS */,
+        end = DESER[u32](POS_OFFSET.span.end) /* IF_TS */ + 2 - tail /* END_IF_TS */,
+        value = DESER[TemplateElementValue](POS_OFFSET.value);
+    if (value.cooked !== null && DESER[bool](POS_OFFSET.lone_surrogates)) {
+        value.cooked = value.cooked
+            .replace(/\uFFFD(.{4})/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16)));
+    }
+    { type: 'TemplateElement', start, end, value, tail }
+"#)]
+pub struct TemplateElementConverter<'a, 'b>(pub &'b TemplateElement<'a>);
+
+impl ESTree for TemplateElementConverter<'_, '_> {
+    fn serialize<S: Serializer>(&self, serializer: S) {
+        let element = self.0;
+        let mut state = serializer.serialize_struct();
+        state.serialize_field("type", &JsonSafeString("TemplateElement"));
+
+        let mut span = element.span;
+        if S::INCLUDE_TS_FIELDS {
+            span.start -= 1;
+            span.end += if element.tail { 1 } else { 2 };
+        }
+        state.serialize_field("start", &span.start);
+        state.serialize_field("end", &span.end);
+
+        state.serialize_field("value", &TemplateElementValue(element));
+        state.serialize_field("tail", &element.tail);
+        state.end();
+    }
+}
+
 /// Serializer for `value` field of `TemplateElement`.
 ///
 /// Handle when `lone_surrogates` flag is set, indicating the cooked string contains lone surrogates.
+///
+/// Implementation for `raw_deser` is included in `TemplateElementConverter` above.
 #[ast_meta]
 #[estree(
     ts_type = "TemplateElementValue",
-    raw_deser = r#"
-        let value = DESER[TemplateElementValue](POS_OFFSET.value);
-        if (value.cooked !== null && DESER[bool](POS_OFFSET.lone_surrogates)) {
-            value.cooked = value.cooked
-                .replace(/\uFFFD(.{4})/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16)));
-        }
-        value
-    "#
+    raw_deser = "(() => { throw new Error('Should not appear in deserializer code'); })()"
 )]
 pub struct TemplateElementValue<'a, 'b>(pub &'b TemplateElement<'a>);
 

napi/parser/deserialize-js.js

@@ -150,18 +150,15 @@ function deserializeTaggedTemplateExpression(pos) {
 }
 
 function deserializeTemplateElement(pos) {
-  let value = deserializeTemplateElementValue(pos + 8);
+  const tail = deserializeBool(pos + 40),
+    start = deserializeU32(pos),
+    end = deserializeU32(pos + 4),
+    value = deserializeTemplateElementValue(pos + 8);
   if (value.cooked !== null && deserializeBool(pos + 41)) {
     value.cooked = value.cooked
       .replace(/\uFFFD(.{4})/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16)));
   }
-  return {
-    type: 'TemplateElement',
-    start: deserializeU32(pos),
-    end: deserializeU32(pos + 4),
-    value,
-    tail: deserializeBool(pos + 40),
-  };
+  return { type: 'TemplateElement', start, end, value, tail };
 }
 
 function deserializeTemplateElementValue(pos) {

napi/parser/deserialize-ts.js

@@ -165,18 +165,15 @@ function deserializeTaggedTemplateExpression(pos) {
 }
 
 function deserializeTemplateElement(pos) {
-  let value = deserializeTemplateElementValue(pos + 8);
+  const tail = deserializeBool(pos + 40),
+    start = deserializeU32(pos) - 1,
+    end = deserializeU32(pos + 4) + 2 - tail,
+    value = deserializeTemplateElementValue(pos + 8);
   if (value.cooked !== null && deserializeBool(pos + 41)) {
     value.cooked = value.cooked
       .replace(/\uFFFD(.{4})/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16)));
   }
-  return {
-    type: 'TemplateElement',
-    start: deserializeU32(pos),
-    end: deserializeU32(pos + 4),
-    value,
-    tail: deserializeBool(pos + 40),
-  };
+  return { type: 'TemplateElement', start, end, value, tail };
 }
 
 function deserializeTemplateElementValue(pos) {