u

crates/oxc_ast/src/ast/ts.rs

@@ -41,20 +41,10 @@ export interface TSIndexSignatureName extends Span {
 pub struct TSThisParameter<'a> {
     #[serde(flatten)]
     pub span: Span,
-    pub this: TSThisParameterKeyword,
+    pub this_span: Span,
     pub type_annotation: Option<Box<'a, TSTypeAnnotation<'a>>>,
 }
 
-#[ast]
-#[derive(Debug, Hash)]
-#[generate_derive(CloneIn, GetSpan, GetSpanMut)]
-#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
-#[serde(tag = "type", rename_all = "camelCase")]
-pub struct TSThisParameterKeyword {
-    #[serde(flatten)]
-    pub span: Span,
-}
-
 /// Enum Declaration
 ///
 /// `const_opt` enum `BindingIdentifier` { `EnumBody_opt` }

crates/oxc_ast/src/generated/assert_layouts.rs

@@ -788,13 +788,9 @@ const _: () = {
     assert!(size_of::<TSThisParameter>() == 24usize);
     assert!(align_of::<TSThisParameter>() == 8usize);
     assert!(offset_of!(TSThisParameter, span) == 0usize);
-    assert!(offset_of!(TSThisParameter, this) == 8usize);
+    assert!(offset_of!(TSThisParameter, this_span) == 8usize);
     assert!(offset_of!(TSThisParameter, type_annotation) == 16usize);
 
-    assert!(size_of::<TSThisParameterKeyword>() == 8usize);
-    assert!(align_of::<TSThisParameterKeyword>() == 4usize);
-    assert!(offset_of!(TSThisParameterKeyword, span) == 0usize);
-
     assert!(size_of::<TSEnumDeclaration>() == 80usize);
     assert!(align_of::<TSEnumDeclaration>() == 8usize);
     assert!(offset_of!(TSEnumDeclaration, span) == 0usize);
@@ -2346,13 +2342,9 @@ const _: () = {
     assert!(size_of::<TSThisParameter>() == 20usize);
     assert!(align_of::<TSThisParameter>() == 4usize);
     assert!(offset_of!(TSThisParameter, span) == 0usize);
-    assert!(offset_of!(TSThisParameter, this) == 8usize);
+    assert!(offset_of!(TSThisParameter, this_span) == 8usize);
     assert!(offset_of!(TSThisParameter, type_annotation) == 16usize);
 
-    assert!(size_of::<TSThisParameterKeyword>() == 8usize);
-    assert!(align_of::<TSThisParameterKeyword>() == 4usize);
-    assert!(offset_of!(TSThisParameterKeyword, span) == 0usize);
-
     assert!(size_of::<TSEnumDeclaration>() == 52usize);
     assert!(align_of::<TSEnumDeclaration>() == 4usize);
     assert!(offset_of!(TSEnumDeclaration, span) == 0usize);

crates/oxc_ast/src/generated/ast_builder.rs

@@ -7878,19 +7878,23 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
-    /// - this
+    /// - this_span
     /// - type_annotation
     #[inline]
     pub fn ts_this_parameter<T1>(
         self,
         span: Span,
-        this: TSThisParameterKeyword,
+        this_span: Span,
         type_annotation: T1,
     ) -> TSThisParameter<'a>
     where
         T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
-        TSThisParameter { span, this, type_annotation: type_annotation.into_in(self.allocator) }
+        TSThisParameter {
+            span,
+            this_span,
+            type_annotation: type_annotation.into_in(self.allocator),
+        }
     }
 
     /// Builds a [`TSThisParameter`] and stores it in the memory arena.
@@ -7899,19 +7903,19 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
-    /// - this
+    /// - this_span
     /// - type_annotation
     #[inline]
     pub fn alloc_ts_this_parameter<T1>(
         self,
         span: Span,
-        this: TSThisParameterKeyword,
+        this_span: Span,
         type_annotation: T1,
     ) -> Box<'a, TSThisParameter<'a>>
     where
         T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
-        Box::new_in(self.ts_this_parameter(span, this, type_annotation), self.allocator)
+        Box::new_in(self.ts_this_parameter(span, this_span, type_annotation), self.allocator)
     }
 
     /// Builds a [`TSEnumDeclaration`]

crates/oxc_ast/src/generated/derive_clone_in.rs

@@ -2278,19 +2278,12 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSThisParameter<'old_alloc>
     fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned {
         TSThisParameter {
             span: self.span.clone_in(allocator),
-            this: self.this.clone_in(allocator),
+            this_span: self.this_span.clone_in(allocator),
             type_annotation: self.type_annotation.clone_in(allocator),
         }
     }
 }
 
-impl<'alloc> CloneIn<'alloc> for TSThisParameterKeyword {
-    type Cloned = TSThisParameterKeyword;
-    fn clone_in(&self, allocator: &'alloc Allocator) -> Self::Cloned {
-        TSThisParameterKeyword { span: self.span.clone_in(allocator) }
-    }
-}
-
 impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSEnumDeclaration<'old_alloc> {
     type Cloned = TSEnumDeclaration<'new_alloc>;
     fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned {

crates/oxc_ast/src/generated/derive_content_eq.rs

@@ -2378,7 +2378,7 @@ impl<'a> ContentEq for ModuleExportName<'a> {
 
 impl<'a> ContentEq for TSThisParameter<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.this.content_eq(&other.this) && self.type_annotation.content_eq(&other.type_annotation)
+        self.type_annotation.content_eq(&other.type_annotation)
     }
 }
 

crates/oxc_ast/src/generated/derive_get_span.rs

@@ -1259,13 +1259,6 @@ impl<'a> GetSpan for TSThisParameter<'a> {
     }
 }
 
-impl GetSpan for TSThisParameterKeyword {
-    #[inline]
-    fn span(&self) -> Span {
-        self.span
-    }
-}
-
 impl<'a> GetSpan for TSEnumDeclaration<'a> {
     #[inline]
     fn span(&self) -> Span {

crates/oxc_ast/src/generated/derive_get_span_mut.rs

@@ -1259,13 +1259,6 @@ impl<'a> GetSpanMut for TSThisParameter<'a> {
     }
 }
 
-impl GetSpanMut for TSThisParameterKeyword {
-    #[inline]
-    fn span_mut(&mut self) -> &mut Span {
-        &mut self.span
-    }
-}
-
 impl<'a> GetSpanMut for TSEnumDeclaration<'a> {
     #[inline]
     fn span_mut(&mut self) -> &mut Span {

crates/oxc_parser/src/ts/statement.rs

@@ -476,7 +476,7 @@ impl<'a> ParserImpl<'a> {
 
         let this_span = self.start_span();
         self.bump_any();
-        let this = TSThisParameterKeyword { span: self.end_span(this_span) };
+        let this = self.end_span(this_span);
 
         let type_annotation = self.parse_ts_type_annotation()?;
         Ok(self.ast.ts_this_parameter(self.end_span(span), this, type_annotation))

crates/oxc_traverse/src/generated/ancestor.rs

@@ -9285,7 +9285,7 @@ impl<'a, 't> JSXSpreadChildWithoutExpression<'a, 't> {
 }
 
 pub(crate) const OFFSET_TS_THIS_PARAMETER_SPAN: usize = offset_of!(TSThisParameter, span);
-pub(crate) const OFFSET_TS_THIS_PARAMETER_THIS: usize = offset_of!(TSThisParameter, this);
+pub(crate) const OFFSET_TS_THIS_PARAMETER_THIS_SPAN: usize = offset_of!(TSThisParameter, this_span);
 pub(crate) const OFFSET_TS_THIS_PARAMETER_TYPE_ANNOTATION: usize =
     offset_of!(TSThisParameter, type_annotation);
 
@@ -9303,11 +9303,8 @@ impl<'a, 't> TSThisParameterWithoutTypeAnnotation<'a, 't> {
     }
 
     #[inline]
-    pub fn this(self) -> &'t TSThisParameterKeyword {
-        unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_THIS_PARAMETER_THIS)
-                as *const TSThisParameterKeyword)
-        }
+    pub fn this_span(self) -> &'t Span {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_TS_THIS_PARAMETER_THIS_SPAN) as *const Span) }
     }
 }
 

tasks/ast_tools/src/derives/content_eq.rs

@@ -14,9 +14,10 @@ define_derive! {
     pub struct DeriveContentEq;
 }
 
-const IGNORE_FIELDS: [(/* field name */ &str, /* field type */ &str); 5] = [
+const IGNORE_FIELDS: [(/* field name */ &str, /* field type */ &str); 6] = [
     ("span", "Span"),
     ("trailing_comma", "Span"),
+    ("this_span", "Span"),
     ("scope_id", "ScopeId"),
     ("symbol_id", "SymbolId"),
     ("reference_id", "ReferenceId"),