refactor(ast): introduce ThisParameter

crates/oxc_ast/src/ast/js.rs

@@ -1530,6 +1530,7 @@ pub struct Function<'a> {
     pub expression: bool,
     pub generator: bool,
     pub r#async: bool,
+    pub this_param: Option<TSThisParameter<'a>>,
     pub params: Box<'a, FormalParameters<'a>>,
     pub body: Option<Box<'a, FunctionBody<'a>>>,
     pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
@@ -1590,10 +1591,6 @@ impl<'a> FormalParameters<'a> {
     pub fn parameters_count(&self) -> usize {
         self.items.len() + self.rest.as_ref().map_or(0, |_| 1)
     }
-
-    pub fn this_parameter(&self) -> Option<&FormalParameter<'a>> {
-        self.items.first().filter(|item| matches!(&item.pattern.kind, BindingPatternKind::BindingIdentifier(ident) if ident.name == "this"))
-    }
 }
 
 #[derive(Debug, Hash)]

crates/oxc_ast/src/ast/ts.rs

@@ -11,6 +11,14 @@ use serde::Serialize;
 #[allow(clippy::wildcard_imports)]
 use crate::ast::*;
 
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))]
+pub struct TSThisParameter<'a> {
+    #[cfg_attr(feature = "serde", serde(flatten))]
+    pub span: Span,
+    pub type_annotation: Option<Box<'a, TSTypeAnnotation<'a>>>,
+}
+
 /// Enum Declaration
 ///
 /// `const_opt` enum `BindingIdentifier` { `EnumBody_opt` }

crates/oxc_ast/src/ast_builder.rs

@@ -742,6 +742,14 @@ impl<'a> AstBuilder<'a> {
         FormalParameter { span, pattern, accessibility, readonly, decorators }
     }
 
+    pub fn ts_this_parameter(
+        &self,
+        span: Span,
+        type_annotation: Option<Box<'a, TSTypeAnnotation<'a>>>,
+    ) -> TSThisParameter<'a> {
+        TSThisParameter { span, type_annotation }
+    }
+
     pub fn function(
         &self,
         r#type: FunctionType,
@@ -750,6 +758,7 @@ impl<'a> AstBuilder<'a> {
         expression: bool,
         generator: bool,
         r#async: bool,
+        this_param: Option<TSThisParameter<'a>>,
         params: Box<'a, FormalParameters<'a>>,
         body: Option<Box<'a, FunctionBody<'a>>>,
         type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
@@ -763,6 +772,7 @@ impl<'a> AstBuilder<'a> {
             expression,
             generator,
             r#async,
+            this_param,
             params,
             body,
             type_parameters,

crates/oxc_parser/src/js/class.rs

@@ -357,15 +357,11 @@ impl<'a> Parser<'a> {
 
         let value = self.parse_method(r#async, generator)?;
 
-        if kind == MethodDefinitionKind::Get
-            && value.params.parameters_count() != value.params.this_parameter().map_or(0, |_| 1)
-        {
+        if kind == MethodDefinitionKind::Get && value.params.parameters_count() != 0 {
             self.error(diagnostics::GetterParameters(value.params.span));
         }
 
-        if kind == MethodDefinitionKind::Set
-            && value.params.parameters_count() != value.params.this_parameter().map_or(1, |_| 2)
-        {
+        if kind == MethodDefinitionKind::Set && value.params.parameters_count() != 1 {
             self.error(diagnostics::SetterParameters(value.params.span));
         }
 

crates/oxc_parser/src/js/function.rs

@@ -74,6 +74,18 @@ impl<'a> Parser<'a> {
         Ok(self.ast.formal_parameters(self.end_span(span), params_kind, list.elements, list.rest))
     }
 
+    pub(crate) fn parse_formal_parameters_with_ts_this(
+        &mut self,
+        params_kind: FormalParameterKind,
+    ) -> Result<(Option<TSThisParameter<'a>>, Box<'a, FormalParameters<'a>>)> {
+        let span = self.start_span();
+        let list: FormalParameterList<'_> = FormalParameterList::parse(self)?;
+        let formal_parameters =
+            self.ast.formal_parameters(self.end_span(span), params_kind, list.elements, list.rest);
+        let this_param = list.this_param;
+        Ok((this_param, formal_parameters))
+    }
+
     pub(crate) fn parse_function(
         &mut self,
         span: Span,
@@ -88,7 +100,8 @@ impl<'a> Parser<'a> {
 
         let type_parameters = self.parse_ts_type_parameters()?;
 
-        let params = self.parse_formal_parameters(FormalParameterKind::FormalParameter)?;
+        let (this_param, params) =
+            self.parse_formal_parameters_with_ts_this(FormalParameterKind::FormalParameter)?;
 
         let return_type = self.parse_ts_return_type_annotation()?;
 
@@ -124,6 +137,7 @@ impl<'a> Parser<'a> {
             false, // expression
             generator,
             r#async,
+            this_param,
             params,
             body,
             type_parameters,

crates/oxc_parser/src/js/list.rs

@@ -234,11 +234,12 @@ impl<'a> SeparatedList<'a> for SequenceExpressionList<'a> {
 pub struct FormalParameterList<'a> {
     pub elements: Vec<'a, FormalParameter<'a>>,
     pub rest: Option<oxc_allocator::Box<'a, RestElement<'a>>>,
+    pub this_param: Option<TSThisParameter<'a>>,
 }
 
 impl<'a> SeparatedList<'a> for FormalParameterList<'a> {
     fn new(p: &Parser<'a>) -> Self {
-        Self { elements: p.ast.new_vec(), rest: None }
+        Self { elements: p.ast.new_vec(), rest: None, this_param: None }
     }
 
     fn open(&self) -> Kind {
@@ -260,8 +261,8 @@ impl<'a> SeparatedList<'a> for FormalParameterList<'a> {
 
         match p.cur_kind() {
             Kind::This if p.ts_enabled() => {
-                let formal_parameter = p.parse_ts_this_parameter()?;
-                self.elements.push(formal_parameter);
+                let this_parameter = p.parse_ts_this_parameter()?;
+                self.this_param.replace(this_parameter);
             }
             Kind::Dot3 => {
                 let rest = p.parse_rest_element()?;

crates/oxc_parser/src/js/object.rs

@@ -217,7 +217,7 @@ impl<'a> Parser<'a> {
         self.expect(Kind::Get)?;
         let (key, computed) = self.parse_property_name()?;
         let method = self.parse_method(false, false)?;
-        if method.params.parameters_count() != method.params.this_parameter().map_or(0, |_| 1) {
+        if method.params.parameters_count() != 0 {
             self.error(diagnostics::GetterParameters(method.params.span));
         }
         let value = self.ast.function_expression(method);
@@ -241,7 +241,7 @@ impl<'a> Parser<'a> {
         let (key, computed) = self.parse_property_name()?;
         let method = self.parse_method(false, false)?;
 
-        if method.params.parameters_count() != method.params.this_parameter().map_or(1, |_| 2) {
+        if method.params.parameters_count() != 1 {
             self.error(diagnostics::SetterParameters(method.params.span));
         }
 

crates/oxc_parser/src/ts/statement.rs

@@ -422,19 +422,11 @@ impl<'a> Parser<'a> {
         ))
     }
 
-    pub(crate) fn parse_ts_this_parameter(&mut self) -> Result<FormalParameter<'a>> {
+    pub(crate) fn parse_ts_this_parameter(&mut self) -> Result<TSThisParameter<'a>> {
         let span = self.start_span();
-        let (ident_span, name) = self.parse_identifier_kind(Kind::This);
+        let _ = self.parse_identifier_kind(Kind::This);
         let type_annotation = self.parse_ts_type_annotation()?;
-        let kind = self.ast.binding_pattern_identifier(BindingIdentifier::new(ident_span, name));
-        let binding = self.ast.binding_pattern(kind, type_annotation, /* optional */ false);
-        Ok(self.ast.formal_parameter(
-            self.end_span(span),
-            binding,
-            /* accessibility */ None,
-            /* readonly */ false,
-            /* decorators */ self.ast.new_vec(),
-        ))
+        Ok(self.ast.ts_this_parameter(self.end_span(span), type_annotation))
     }
 
     pub(crate) fn eat_decorators(&mut self) -> Result<()> {

crates/oxc_transformer/src/es2015/arrow_functions.rs

@@ -130,6 +130,7 @@ impl<'a> ArrowFunctions<'a> {
                 false,
                 arrow_expr.generator,
                 arrow_expr.r#async,
+                None,
                 self.ast.copy(&arrow_expr.params),
                 Some(body),
                 self.ast.copy(&arrow_expr.type_parameters),

crates/oxc_transformer/src/lib.rs

@@ -223,18 +223,6 @@ impl<'a> VisitMut<'a> for Transformer<'a> {
         });
     }
 
-    fn visit_formal_parameters(&mut self, params: &mut FormalParameters<'a>) {
-        self.typescript.as_mut().map(|t| t.transform_formal_parameters(params));
-
-        for param in params.items.iter_mut() {
-            self.visit_formal_parameter(param);
-        }
-
-        if let Some(rest) = &mut params.rest {
-            self.visit_rest_element(rest);
-        }
-    }
-
     fn visit_variable_declarator(&mut self, declarator: &mut VariableDeclarator<'a>) {
         self.es2015_function_name.as_mut().map(|t| t.transform_variable_declarator(declarator));
 

crates/oxc_transformer/src/typescript/mod.rs

@@ -33,13 +33,6 @@ impl<'a> TypeScript<'a> {
         Self { ast, ctx, verbatim_module_syntax, export_name_set: FxHashSet::default() }
     }
 
-    #[allow(clippy::unused_self)]
-    pub fn transform_formal_parameters(&self, params: &mut FormalParameters<'a>) {
-        if params.items.get(0).is_some_and(|param| matches!(&param.pattern.kind, BindingPatternKind::BindingIdentifier(ident) if ident.name =="this")) {
-            params.items.remove(0);
-        }
-    }
-
     /// ```TypeScript
     /// enum Foo {
     ///   X