From f68b659713f18d943ed023e0e43e5c2fdf966e14 Mon Sep 17 00:00:00 2001 From: Dunqing <29533304+Dunqing@users.noreply.github.com> Date: Fri, 19 Jul 2024 14:12:05 +0000 Subject: [PATCH] refactor(ast)!: reorder fields of `ArrowFunctionExpression` (#4364) Found in #4328 Same as #4248 --- crates/oxc_ast/src/ast/js.rs | 5 +- crates/oxc_ast/src/generated/ast_builder.rs | 60 +-- crates/oxc_ast/src/generated/visit.rs | 452 +++++++++--------- crates/oxc_ast/src/generated/visit_mut.rs | 484 ++++++++++---------- crates/oxc_parser/src/js/arrow.rs | 4 +- crates/oxc_traverse/src/ancestor.rs | 118 ++--- crates/oxc_traverse/src/walk.rs | 32 +- 7 files changed, 577 insertions(+), 578 deletions(-) diff --git a/crates/oxc_ast/src/ast/js.rs b/crates/oxc_ast/src/ast/js.rs index 7fe22e22e1299..dbf2d1e1163d2 100644 --- a/crates/oxc_ast/src/ast/js.rs +++ b/crates/oxc_ast/src/ast/js.rs @@ -1558,12 +1558,11 @@ pub struct ArrowFunctionExpression<'a> { /// Is the function body an arrow expression? i.e. `() => expr` instead of `() => {}` pub expression: bool, pub r#async: bool, + pub type_parameters: Option>>, pub params: Box<'a, FormalParameters<'a>>, + pub return_type: Option>>, /// See `expression` for whether this arrow expression returns an expression. pub body: Box<'a, FunctionBody<'a>>, - - pub type_parameters: Option>>, - pub return_type: Option>>, pub scope_id: Cell>, } diff --git a/crates/oxc_ast/src/generated/ast_builder.rs b/crates/oxc_ast/src/generated/ast_builder.rs index 70d02d1eeacca..86cac8b2bddfd 100644 --- a/crates/oxc_ast/src/generated/ast_builder.rs +++ b/crates/oxc_ast/src/generated/ast_builder.rs @@ -351,25 +351,25 @@ impl<'a> AstBuilder<'a> { span: Span, expression: bool, r#async: bool, - params: T1, - body: T2, - type_parameters: T3, - return_type: T4, + type_parameters: T1, + params: T2, + return_type: T3, + body: T4, ) -> Expression<'a> where - T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, - T2: IntoIn<'a, Box<'a, FunctionBody<'a>>>, - T3: IntoIn<'a, Option>>>, - T4: IntoIn<'a, Option>>>, + T1: IntoIn<'a, Option>>>, + T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, + T3: IntoIn<'a, Option>>>, + T4: IntoIn<'a, Box<'a, FunctionBody<'a>>>, { Expression::ArrowFunctionExpression(self.alloc(self.arrow_function_expression( span, expression, r#async, - params, - body, type_parameters, + params, return_type, + body, ))) } @@ -3863,25 +3863,25 @@ impl<'a> AstBuilder<'a> { span: Span, expression: bool, r#async: bool, - params: T1, - body: T2, - type_parameters: T3, - return_type: T4, + type_parameters: T1, + params: T2, + return_type: T3, + body: T4, ) -> ArrowFunctionExpression<'a> where - T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, - T2: IntoIn<'a, Box<'a, FunctionBody<'a>>>, - T3: IntoIn<'a, Option>>>, - T4: IntoIn<'a, Option>>>, + T1: IntoIn<'a, Option>>>, + T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, + T3: IntoIn<'a, Option>>>, + T4: IntoIn<'a, Box<'a, FunctionBody<'a>>>, { ArrowFunctionExpression { span, expression, r#async, - params: params.into_in(self.allocator), - body: body.into_in(self.allocator), type_parameters: type_parameters.into_in(self.allocator), + params: params.into_in(self.allocator), return_type: return_type.into_in(self.allocator), + body: body.into_in(self.allocator), scope_id: Default::default(), } } @@ -3892,25 +3892,25 @@ impl<'a> AstBuilder<'a> { span: Span, expression: bool, r#async: bool, - params: T1, - body: T2, - type_parameters: T3, - return_type: T4, + type_parameters: T1, + params: T2, + return_type: T3, + body: T4, ) -> Box<'a, ArrowFunctionExpression<'a>> where - T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, - T2: IntoIn<'a, Box<'a, FunctionBody<'a>>>, - T3: IntoIn<'a, Option>>>, - T4: IntoIn<'a, Option>>>, + T1: IntoIn<'a, Option>>>, + T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, + T3: IntoIn<'a, Option>>>, + T4: IntoIn<'a, Box<'a, FunctionBody<'a>>>, { self.arrow_function_expression( span, expression, r#async, - params, - body, type_parameters, + params, return_type, + body, ) .into_in(self.allocator) } diff --git a/crates/oxc_ast/src/generated/visit.rs b/crates/oxc_ast/src/generated/visit.rs index 9f99303bb8069..d7bf71dae1e6b 100644 --- a/crates/oxc_ast/src/generated/visit.rs +++ b/crates/oxc_ast/src/generated/visit.rs @@ -216,188 +216,188 @@ pub trait Visit<'a>: Sized { } #[inline] - fn visit_formal_parameters(&mut self, it: &FormalParameters<'a>) { - walk_formal_parameters(self, it); + fn visit_ts_type_parameter_declaration(&mut self, it: &TSTypeParameterDeclaration<'a>) { + walk_ts_type_parameter_declaration(self, it); } #[inline] - fn visit_formal_parameter_list(&mut self, it: &Vec<'a, FormalParameter<'a>>) { - walk_formal_parameter_list(self, it); + fn visit_ts_type_parameters(&mut self, it: &Vec<'a, TSTypeParameter<'a>>) { + walk_ts_type_parameters(self, it); } #[inline] - fn visit_formal_parameter(&mut self, it: &FormalParameter<'a>) { - walk_formal_parameter(self, it); + fn visit_ts_type_parameter(&mut self, it: &TSTypeParameter<'a>) { + walk_ts_type_parameter(self, it); } #[inline] - fn visit_decorators(&mut self, it: &Vec<'a, Decorator<'a>>) { - walk_decorators(self, it); + fn visit_binding_identifier(&mut self, it: &BindingIdentifier<'a>) { + walk_binding_identifier(self, it); } #[inline] - fn visit_decorator(&mut self, it: &Decorator<'a>) { - walk_decorator(self, it); + fn visit_ts_type(&mut self, it: &TSType<'a>) { + walk_ts_type(self, it); } #[inline] - fn visit_binding_pattern(&mut self, it: &BindingPattern<'a>) { - walk_binding_pattern(self, it); + fn visit_ts_any_keyword(&mut self, it: &TSAnyKeyword) { + walk_ts_any_keyword(self, it); } #[inline] - fn visit_binding_pattern_kind(&mut self, it: &BindingPatternKind<'a>) { - walk_binding_pattern_kind(self, it); + fn visit_ts_big_int_keyword(&mut self, it: &TSBigIntKeyword) { + walk_ts_big_int_keyword(self, it); } #[inline] - fn visit_binding_identifier(&mut self, it: &BindingIdentifier<'a>) { - walk_binding_identifier(self, it); + fn visit_ts_boolean_keyword(&mut self, it: &TSBooleanKeyword) { + walk_ts_boolean_keyword(self, it); } #[inline] - fn visit_object_pattern(&mut self, it: &ObjectPattern<'a>) { - walk_object_pattern(self, it); + fn visit_ts_intrinsic_keyword(&mut self, it: &TSIntrinsicKeyword) { + walk_ts_intrinsic_keyword(self, it); } #[inline] - fn visit_binding_properties(&mut self, it: &Vec<'a, BindingProperty<'a>>) { - walk_binding_properties(self, it); + fn visit_ts_never_keyword(&mut self, it: &TSNeverKeyword) { + walk_ts_never_keyword(self, it); } #[inline] - fn visit_binding_property(&mut self, it: &BindingProperty<'a>) { - walk_binding_property(self, it); + fn visit_ts_null_keyword(&mut self, it: &TSNullKeyword) { + walk_ts_null_keyword(self, it); } #[inline] - fn visit_property_key(&mut self, it: &PropertyKey<'a>) { - walk_property_key(self, it); + fn visit_ts_number_keyword(&mut self, it: &TSNumberKeyword) { + walk_ts_number_keyword(self, it); } #[inline] - fn visit_private_identifier(&mut self, it: &PrivateIdentifier<'a>) { - walk_private_identifier(self, it); + fn visit_ts_object_keyword(&mut self, it: &TSObjectKeyword) { + walk_ts_object_keyword(self, it); } #[inline] - fn visit_binding_rest_element(&mut self, it: &BindingRestElement<'a>) { - walk_binding_rest_element(self, it); + fn visit_ts_string_keyword(&mut self, it: &TSStringKeyword) { + walk_ts_string_keyword(self, it); } #[inline] - fn visit_array_pattern(&mut self, it: &ArrayPattern<'a>) { - walk_array_pattern(self, it); + fn visit_ts_symbol_keyword(&mut self, it: &TSSymbolKeyword) { + walk_ts_symbol_keyword(self, it); } #[inline] - fn visit_assignment_pattern(&mut self, it: &AssignmentPattern<'a>) { - walk_assignment_pattern(self, it); + fn visit_ts_undefined_keyword(&mut self, it: &TSUndefinedKeyword) { + walk_ts_undefined_keyword(self, it); } #[inline] - fn visit_ts_type_annotation(&mut self, it: &TSTypeAnnotation<'a>) { - walk_ts_type_annotation(self, it); + fn visit_ts_unknown_keyword(&mut self, it: &TSUnknownKeyword) { + walk_ts_unknown_keyword(self, it); } #[inline] - fn visit_ts_type(&mut self, it: &TSType<'a>) { - walk_ts_type(self, it); + fn visit_ts_void_keyword(&mut self, it: &TSVoidKeyword) { + walk_ts_void_keyword(self, it); } #[inline] - fn visit_ts_any_keyword(&mut self, it: &TSAnyKeyword) { - walk_ts_any_keyword(self, it); + fn visit_ts_array_type(&mut self, it: &TSArrayType<'a>) { + walk_ts_array_type(self, it); } #[inline] - fn visit_ts_big_int_keyword(&mut self, it: &TSBigIntKeyword) { - walk_ts_big_int_keyword(self, it); + fn visit_ts_conditional_type(&mut self, it: &TSConditionalType<'a>) { + walk_ts_conditional_type(self, it); } #[inline] - fn visit_ts_boolean_keyword(&mut self, it: &TSBooleanKeyword) { - walk_ts_boolean_keyword(self, it); + fn visit_ts_constructor_type(&mut self, it: &TSConstructorType<'a>) { + walk_ts_constructor_type(self, it); } #[inline] - fn visit_ts_intrinsic_keyword(&mut self, it: &TSIntrinsicKeyword) { - walk_ts_intrinsic_keyword(self, it); + fn visit_formal_parameters(&mut self, it: &FormalParameters<'a>) { + walk_formal_parameters(self, it); } #[inline] - fn visit_ts_never_keyword(&mut self, it: &TSNeverKeyword) { - walk_ts_never_keyword(self, it); + fn visit_formal_parameter_list(&mut self, it: &Vec<'a, FormalParameter<'a>>) { + walk_formal_parameter_list(self, it); } #[inline] - fn visit_ts_null_keyword(&mut self, it: &TSNullKeyword) { - walk_ts_null_keyword(self, it); + fn visit_formal_parameter(&mut self, it: &FormalParameter<'a>) { + walk_formal_parameter(self, it); } #[inline] - fn visit_ts_number_keyword(&mut self, it: &TSNumberKeyword) { - walk_ts_number_keyword(self, it); + fn visit_decorators(&mut self, it: &Vec<'a, Decorator<'a>>) { + walk_decorators(self, it); } #[inline] - fn visit_ts_object_keyword(&mut self, it: &TSObjectKeyword) { - walk_ts_object_keyword(self, it); + fn visit_decorator(&mut self, it: &Decorator<'a>) { + walk_decorator(self, it); } #[inline] - fn visit_ts_string_keyword(&mut self, it: &TSStringKeyword) { - walk_ts_string_keyword(self, it); + fn visit_binding_pattern(&mut self, it: &BindingPattern<'a>) { + walk_binding_pattern(self, it); } #[inline] - fn visit_ts_symbol_keyword(&mut self, it: &TSSymbolKeyword) { - walk_ts_symbol_keyword(self, it); + fn visit_binding_pattern_kind(&mut self, it: &BindingPatternKind<'a>) { + walk_binding_pattern_kind(self, it); } #[inline] - fn visit_ts_undefined_keyword(&mut self, it: &TSUndefinedKeyword) { - walk_ts_undefined_keyword(self, it); + fn visit_object_pattern(&mut self, it: &ObjectPattern<'a>) { + walk_object_pattern(self, it); } #[inline] - fn visit_ts_unknown_keyword(&mut self, it: &TSUnknownKeyword) { - walk_ts_unknown_keyword(self, it); + fn visit_binding_properties(&mut self, it: &Vec<'a, BindingProperty<'a>>) { + walk_binding_properties(self, it); } #[inline] - fn visit_ts_void_keyword(&mut self, it: &TSVoidKeyword) { - walk_ts_void_keyword(self, it); + fn visit_binding_property(&mut self, it: &BindingProperty<'a>) { + walk_binding_property(self, it); } #[inline] - fn visit_ts_array_type(&mut self, it: &TSArrayType<'a>) { - walk_ts_array_type(self, it); + fn visit_property_key(&mut self, it: &PropertyKey<'a>) { + walk_property_key(self, it); } #[inline] - fn visit_ts_conditional_type(&mut self, it: &TSConditionalType<'a>) { - walk_ts_conditional_type(self, it); + fn visit_private_identifier(&mut self, it: &PrivateIdentifier<'a>) { + walk_private_identifier(self, it); } #[inline] - fn visit_ts_constructor_type(&mut self, it: &TSConstructorType<'a>) { - walk_ts_constructor_type(self, it); + fn visit_binding_rest_element(&mut self, it: &BindingRestElement<'a>) { + walk_binding_rest_element(self, it); } #[inline] - fn visit_ts_type_parameter_declaration(&mut self, it: &TSTypeParameterDeclaration<'a>) { - walk_ts_type_parameter_declaration(self, it); + fn visit_array_pattern(&mut self, it: &ArrayPattern<'a>) { + walk_array_pattern(self, it); } #[inline] - fn visit_ts_type_parameters(&mut self, it: &Vec<'a, TSTypeParameter<'a>>) { - walk_ts_type_parameters(self, it); + fn visit_assignment_pattern(&mut self, it: &AssignmentPattern<'a>) { + walk_assignment_pattern(self, it); } #[inline] - fn visit_ts_type_parameter(&mut self, it: &TSTypeParameter<'a>) { - walk_ts_type_parameter(self, it); + fn visit_ts_type_annotation(&mut self, it: &TSTypeAnnotation<'a>) { + walk_ts_type_annotation(self, it); } #[inline] @@ -1718,177 +1718,57 @@ pub mod walk { }, &it.scope_id, ); - visitor.visit_formal_parameters(&it.params); - visitor.visit_function_body(&it.body); if let Some(type_parameters) = &it.type_parameters { visitor.visit_ts_type_parameter_declaration(type_parameters); } + visitor.visit_formal_parameters(&it.params); if let Some(return_type) = &it.return_type { visitor.visit_ts_type_annotation(return_type); } + visitor.visit_function_body(&it.body); visitor.leave_scope(); visitor.leave_node(kind); } #[inline] - pub fn walk_formal_parameters<'a, V: Visit<'a>>(visitor: &mut V, it: &FormalParameters<'a>) { - let kind = AstKind::FormalParameters(visitor.alloc(it)); - visitor.enter_node(kind); - visitor.visit_formal_parameter_list(&it.items); - if let Some(rest) = &it.rest { - visitor.visit_binding_rest_element(rest); - } - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_formal_parameter_list<'a, V: Visit<'a>>( - visitor: &mut V, - it: &Vec<'a, FormalParameter<'a>>, - ) { - for el in it.iter() { - visitor.visit_formal_parameter(el); - } - } - - #[inline] - pub fn walk_formal_parameter<'a, V: Visit<'a>>(visitor: &mut V, it: &FormalParameter<'a>) { - let kind = AstKind::FormalParameter(visitor.alloc(it)); - visitor.enter_node(kind); - visitor.visit_decorators(&it.decorators); - visitor.visit_binding_pattern(&it.pattern); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_decorators<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, Decorator<'a>>) { - for el in it.iter() { - visitor.visit_decorator(el); - } - } - - #[inline] - pub fn walk_decorator<'a, V: Visit<'a>>(visitor: &mut V, it: &Decorator<'a>) { - let kind = AstKind::Decorator(visitor.alloc(it)); - visitor.enter_node(kind); - visitor.visit_expression(&it.expression); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_binding_pattern<'a, V: Visit<'a>>(visitor: &mut V, it: &BindingPattern<'a>) { - // NOTE: AstKind doesn't exists! - visitor.visit_binding_pattern_kind(&it.kind); - if let Some(type_annotation) = &it.type_annotation { - visitor.visit_ts_type_annotation(type_annotation); - } - } - - #[inline] - pub fn walk_binding_pattern_kind<'a, V: Visit<'a>>( + pub fn walk_ts_type_parameter_declaration<'a, V: Visit<'a>>( visitor: &mut V, - it: &BindingPatternKind<'a>, + it: &TSTypeParameterDeclaration<'a>, ) { - match it { - BindingPatternKind::BindingIdentifier(it) => visitor.visit_binding_identifier(it), - BindingPatternKind::ObjectPattern(it) => visitor.visit_object_pattern(it), - BindingPatternKind::ArrayPattern(it) => visitor.visit_array_pattern(it), - BindingPatternKind::AssignmentPattern(it) => visitor.visit_assignment_pattern(it), - } - } - - #[inline] - pub fn walk_binding_identifier<'a, V: Visit<'a>>(visitor: &mut V, it: &BindingIdentifier<'a>) { - let kind = AstKind::BindingIdentifier(visitor.alloc(it)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_object_pattern<'a, V: Visit<'a>>(visitor: &mut V, it: &ObjectPattern<'a>) { - let kind = AstKind::ObjectPattern(visitor.alloc(it)); + let kind = AstKind::TSTypeParameterDeclaration(visitor.alloc(it)); visitor.enter_node(kind); - visitor.visit_binding_properties(&it.properties); - if let Some(rest) = &it.rest { - visitor.visit_binding_rest_element(rest); - } + visitor.visit_ts_type_parameters(&it.params); visitor.leave_node(kind); } #[inline] - pub fn walk_binding_properties<'a, V: Visit<'a>>( + pub fn walk_ts_type_parameters<'a, V: Visit<'a>>( visitor: &mut V, - it: &Vec<'a, BindingProperty<'a>>, + it: &Vec<'a, TSTypeParameter<'a>>, ) { for el in it.iter() { - visitor.visit_binding_property(el); - } - } - - #[inline] - pub fn walk_binding_property<'a, V: Visit<'a>>(visitor: &mut V, it: &BindingProperty<'a>) { - // NOTE: AstKind doesn't exists! - visitor.visit_property_key(&it.key); - visitor.visit_binding_pattern(&it.value); - } - - #[inline] - pub fn walk_property_key<'a, V: Visit<'a>>(visitor: &mut V, it: &PropertyKey<'a>) { - let kind = AstKind::PropertyKey(visitor.alloc(it)); - visitor.enter_node(kind); - match it { - PropertyKey::StaticIdentifier(it) => visitor.visit_identifier_name(it), - PropertyKey::PrivateIdentifier(it) => visitor.visit_private_identifier(it), - match_expression!(PropertyKey) => visitor.visit_expression(it.to_expression()), + visitor.visit_ts_type_parameter(el); } - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_private_identifier<'a, V: Visit<'a>>(visitor: &mut V, it: &PrivateIdentifier<'a>) { - let kind = AstKind::PrivateIdentifier(visitor.alloc(it)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_binding_rest_element<'a, V: Visit<'a>>( - visitor: &mut V, - it: &BindingRestElement<'a>, - ) { - let kind = AstKind::BindingRestElement(visitor.alloc(it)); - visitor.enter_node(kind); - visitor.visit_binding_pattern(&it.argument); - visitor.leave_node(kind); } #[inline] - pub fn walk_array_pattern<'a, V: Visit<'a>>(visitor: &mut V, it: &ArrayPattern<'a>) { - let kind = AstKind::ArrayPattern(visitor.alloc(it)); + pub fn walk_ts_type_parameter<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeParameter<'a>) { + let kind = AstKind::TSTypeParameter(visitor.alloc(it)); visitor.enter_node(kind); - for elements in it.elements.iter().flatten() { - visitor.visit_binding_pattern(elements); + visitor.visit_binding_identifier(&it.name); + if let Some(constraint) = &it.constraint { + visitor.visit_ts_type(constraint); } - if let Some(rest) = &it.rest { - visitor.visit_binding_rest_element(rest); + if let Some(default) = &it.default { + visitor.visit_ts_type(default); } visitor.leave_node(kind); } #[inline] - pub fn walk_assignment_pattern<'a, V: Visit<'a>>(visitor: &mut V, it: &AssignmentPattern<'a>) { - let kind = AstKind::AssignmentPattern(visitor.alloc(it)); - visitor.enter_node(kind); - visitor.visit_binding_pattern(&it.left); - visitor.visit_expression(&it.right); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_ts_type_annotation<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeAnnotation<'a>) { - let kind = AstKind::TSTypeAnnotation(visitor.alloc(it)); + pub fn walk_binding_identifier<'a, V: Visit<'a>>(visitor: &mut V, it: &BindingIdentifier<'a>) { + let kind = AstKind::BindingIdentifier(visitor.alloc(it)); visitor.enter_node(kind); - visitor.visit_ts_type(&it.type_annotation); visitor.leave_node(kind); } @@ -2056,40 +1936,160 @@ pub mod walk { } #[inline] - pub fn walk_ts_type_parameter_declaration<'a, V: Visit<'a>>( + pub fn walk_formal_parameters<'a, V: Visit<'a>>(visitor: &mut V, it: &FormalParameters<'a>) { + let kind = AstKind::FormalParameters(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_formal_parameter_list(&it.items); + if let Some(rest) = &it.rest { + visitor.visit_binding_rest_element(rest); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_formal_parameter_list<'a, V: Visit<'a>>( visitor: &mut V, - it: &TSTypeParameterDeclaration<'a>, + it: &Vec<'a, FormalParameter<'a>>, ) { - let kind = AstKind::TSTypeParameterDeclaration(visitor.alloc(it)); + for el in it.iter() { + visitor.visit_formal_parameter(el); + } + } + + #[inline] + pub fn walk_formal_parameter<'a, V: Visit<'a>>(visitor: &mut V, it: &FormalParameter<'a>) { + let kind = AstKind::FormalParameter(visitor.alloc(it)); visitor.enter_node(kind); - visitor.visit_ts_type_parameters(&it.params); + visitor.visit_decorators(&it.decorators); + visitor.visit_binding_pattern(&it.pattern); visitor.leave_node(kind); } #[inline] - pub fn walk_ts_type_parameters<'a, V: Visit<'a>>( + pub fn walk_decorators<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, Decorator<'a>>) { + for el in it.iter() { + visitor.visit_decorator(el); + } + } + + #[inline] + pub fn walk_decorator<'a, V: Visit<'a>>(visitor: &mut V, it: &Decorator<'a>) { + let kind = AstKind::Decorator(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_binding_pattern<'a, V: Visit<'a>>(visitor: &mut V, it: &BindingPattern<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_binding_pattern_kind(&it.kind); + if let Some(type_annotation) = &it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); + } + } + + #[inline] + pub fn walk_binding_pattern_kind<'a, V: Visit<'a>>( visitor: &mut V, - it: &Vec<'a, TSTypeParameter<'a>>, + it: &BindingPatternKind<'a>, + ) { + match it { + BindingPatternKind::BindingIdentifier(it) => visitor.visit_binding_identifier(it), + BindingPatternKind::ObjectPattern(it) => visitor.visit_object_pattern(it), + BindingPatternKind::ArrayPattern(it) => visitor.visit_array_pattern(it), + BindingPatternKind::AssignmentPattern(it) => visitor.visit_assignment_pattern(it), + } + } + + #[inline] + pub fn walk_object_pattern<'a, V: Visit<'a>>(visitor: &mut V, it: &ObjectPattern<'a>) { + let kind = AstKind::ObjectPattern(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_properties(&it.properties); + if let Some(rest) = &it.rest { + visitor.visit_binding_rest_element(rest); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_binding_properties<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, BindingProperty<'a>>, ) { for el in it.iter() { - visitor.visit_ts_type_parameter(el); + visitor.visit_binding_property(el); } } #[inline] - pub fn walk_ts_type_parameter<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeParameter<'a>) { - let kind = AstKind::TSTypeParameter(visitor.alloc(it)); + pub fn walk_binding_property<'a, V: Visit<'a>>(visitor: &mut V, it: &BindingProperty<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_property_key(&it.key); + visitor.visit_binding_pattern(&it.value); + } + + #[inline] + pub fn walk_property_key<'a, V: Visit<'a>>(visitor: &mut V, it: &PropertyKey<'a>) { + let kind = AstKind::PropertyKey(visitor.alloc(it)); visitor.enter_node(kind); - visitor.visit_binding_identifier(&it.name); - if let Some(constraint) = &it.constraint { - visitor.visit_ts_type(constraint); + match it { + PropertyKey::StaticIdentifier(it) => visitor.visit_identifier_name(it), + PropertyKey::PrivateIdentifier(it) => visitor.visit_private_identifier(it), + match_expression!(PropertyKey) => visitor.visit_expression(it.to_expression()), } - if let Some(default) = &it.default { - visitor.visit_ts_type(default); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_private_identifier<'a, V: Visit<'a>>(visitor: &mut V, it: &PrivateIdentifier<'a>) { + let kind = AstKind::PrivateIdentifier(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_binding_rest_element<'a, V: Visit<'a>>( + visitor: &mut V, + it: &BindingRestElement<'a>, + ) { + let kind = AstKind::BindingRestElement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_pattern(&it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_array_pattern<'a, V: Visit<'a>>(visitor: &mut V, it: &ArrayPattern<'a>) { + let kind = AstKind::ArrayPattern(visitor.alloc(it)); + visitor.enter_node(kind); + for elements in it.elements.iter().flatten() { + visitor.visit_binding_pattern(elements); + } + if let Some(rest) = &it.rest { + visitor.visit_binding_rest_element(rest); } visitor.leave_node(kind); } + #[inline] + pub fn walk_assignment_pattern<'a, V: Visit<'a>>(visitor: &mut V, it: &AssignmentPattern<'a>) { + let kind = AstKind::AssignmentPattern(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_pattern(&it.left); + visitor.visit_expression(&it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_annotation<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeAnnotation<'a>) { + let kind = AstKind::TSTypeAnnotation(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type(&it.type_annotation); + visitor.leave_node(kind); + } + #[inline] pub fn walk_ts_function_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSFunctionType<'a>) { // NOTE: AstKind doesn't exists! diff --git a/crates/oxc_ast/src/generated/visit_mut.rs b/crates/oxc_ast/src/generated/visit_mut.rs index 6879e917e9a60..345da83274595 100644 --- a/crates/oxc_ast/src/generated/visit_mut.rs +++ b/crates/oxc_ast/src/generated/visit_mut.rs @@ -208,188 +208,188 @@ pub trait VisitMut<'a>: Sized { } #[inline] - fn visit_formal_parameters(&mut self, it: &mut FormalParameters<'a>) { - walk_formal_parameters(self, it); + fn visit_ts_type_parameter_declaration(&mut self, it: &mut TSTypeParameterDeclaration<'a>) { + walk_ts_type_parameter_declaration(self, it); } #[inline] - fn visit_formal_parameter_list(&mut self, it: &mut Vec<'a, FormalParameter<'a>>) { - walk_formal_parameter_list(self, it); + fn visit_ts_type_parameters(&mut self, it: &mut Vec<'a, TSTypeParameter<'a>>) { + walk_ts_type_parameters(self, it); } #[inline] - fn visit_formal_parameter(&mut self, it: &mut FormalParameter<'a>) { - walk_formal_parameter(self, it); + fn visit_ts_type_parameter(&mut self, it: &mut TSTypeParameter<'a>) { + walk_ts_type_parameter(self, it); } #[inline] - fn visit_decorators(&mut self, it: &mut Vec<'a, Decorator<'a>>) { - walk_decorators(self, it); + fn visit_binding_identifier(&mut self, it: &mut BindingIdentifier<'a>) { + walk_binding_identifier(self, it); } #[inline] - fn visit_decorator(&mut self, it: &mut Decorator<'a>) { - walk_decorator(self, it); + fn visit_ts_type(&mut self, it: &mut TSType<'a>) { + walk_ts_type(self, it); } #[inline] - fn visit_binding_pattern(&mut self, it: &mut BindingPattern<'a>) { - walk_binding_pattern(self, it); + fn visit_ts_any_keyword(&mut self, it: &mut TSAnyKeyword) { + walk_ts_any_keyword(self, it); } #[inline] - fn visit_binding_pattern_kind(&mut self, it: &mut BindingPatternKind<'a>) { - walk_binding_pattern_kind(self, it); + fn visit_ts_big_int_keyword(&mut self, it: &mut TSBigIntKeyword) { + walk_ts_big_int_keyword(self, it); } #[inline] - fn visit_binding_identifier(&mut self, it: &mut BindingIdentifier<'a>) { - walk_binding_identifier(self, it); + fn visit_ts_boolean_keyword(&mut self, it: &mut TSBooleanKeyword) { + walk_ts_boolean_keyword(self, it); } #[inline] - fn visit_object_pattern(&mut self, it: &mut ObjectPattern<'a>) { - walk_object_pattern(self, it); + fn visit_ts_intrinsic_keyword(&mut self, it: &mut TSIntrinsicKeyword) { + walk_ts_intrinsic_keyword(self, it); } #[inline] - fn visit_binding_properties(&mut self, it: &mut Vec<'a, BindingProperty<'a>>) { - walk_binding_properties(self, it); + fn visit_ts_never_keyword(&mut self, it: &mut TSNeverKeyword) { + walk_ts_never_keyword(self, it); } #[inline] - fn visit_binding_property(&mut self, it: &mut BindingProperty<'a>) { - walk_binding_property(self, it); + fn visit_ts_null_keyword(&mut self, it: &mut TSNullKeyword) { + walk_ts_null_keyword(self, it); } #[inline] - fn visit_property_key(&mut self, it: &mut PropertyKey<'a>) { - walk_property_key(self, it); + fn visit_ts_number_keyword(&mut self, it: &mut TSNumberKeyword) { + walk_ts_number_keyword(self, it); } #[inline] - fn visit_private_identifier(&mut self, it: &mut PrivateIdentifier<'a>) { - walk_private_identifier(self, it); + fn visit_ts_object_keyword(&mut self, it: &mut TSObjectKeyword) { + walk_ts_object_keyword(self, it); } #[inline] - fn visit_binding_rest_element(&mut self, it: &mut BindingRestElement<'a>) { - walk_binding_rest_element(self, it); + fn visit_ts_string_keyword(&mut self, it: &mut TSStringKeyword) { + walk_ts_string_keyword(self, it); } #[inline] - fn visit_array_pattern(&mut self, it: &mut ArrayPattern<'a>) { - walk_array_pattern(self, it); + fn visit_ts_symbol_keyword(&mut self, it: &mut TSSymbolKeyword) { + walk_ts_symbol_keyword(self, it); } #[inline] - fn visit_assignment_pattern(&mut self, it: &mut AssignmentPattern<'a>) { - walk_assignment_pattern(self, it); + fn visit_ts_undefined_keyword(&mut self, it: &mut TSUndefinedKeyword) { + walk_ts_undefined_keyword(self, it); } #[inline] - fn visit_ts_type_annotation(&mut self, it: &mut TSTypeAnnotation<'a>) { - walk_ts_type_annotation(self, it); + fn visit_ts_unknown_keyword(&mut self, it: &mut TSUnknownKeyword) { + walk_ts_unknown_keyword(self, it); } #[inline] - fn visit_ts_type(&mut self, it: &mut TSType<'a>) { - walk_ts_type(self, it); + fn visit_ts_void_keyword(&mut self, it: &mut TSVoidKeyword) { + walk_ts_void_keyword(self, it); } #[inline] - fn visit_ts_any_keyword(&mut self, it: &mut TSAnyKeyword) { - walk_ts_any_keyword(self, it); + fn visit_ts_array_type(&mut self, it: &mut TSArrayType<'a>) { + walk_ts_array_type(self, it); } #[inline] - fn visit_ts_big_int_keyword(&mut self, it: &mut TSBigIntKeyword) { - walk_ts_big_int_keyword(self, it); + fn visit_ts_conditional_type(&mut self, it: &mut TSConditionalType<'a>) { + walk_ts_conditional_type(self, it); } #[inline] - fn visit_ts_boolean_keyword(&mut self, it: &mut TSBooleanKeyword) { - walk_ts_boolean_keyword(self, it); + fn visit_ts_constructor_type(&mut self, it: &mut TSConstructorType<'a>) { + walk_ts_constructor_type(self, it); } #[inline] - fn visit_ts_intrinsic_keyword(&mut self, it: &mut TSIntrinsicKeyword) { - walk_ts_intrinsic_keyword(self, it); + fn visit_formal_parameters(&mut self, it: &mut FormalParameters<'a>) { + walk_formal_parameters(self, it); } #[inline] - fn visit_ts_never_keyword(&mut self, it: &mut TSNeverKeyword) { - walk_ts_never_keyword(self, it); + fn visit_formal_parameter_list(&mut self, it: &mut Vec<'a, FormalParameter<'a>>) { + walk_formal_parameter_list(self, it); } #[inline] - fn visit_ts_null_keyword(&mut self, it: &mut TSNullKeyword) { - walk_ts_null_keyword(self, it); + fn visit_formal_parameter(&mut self, it: &mut FormalParameter<'a>) { + walk_formal_parameter(self, it); } #[inline] - fn visit_ts_number_keyword(&mut self, it: &mut TSNumberKeyword) { - walk_ts_number_keyword(self, it); + fn visit_decorators(&mut self, it: &mut Vec<'a, Decorator<'a>>) { + walk_decorators(self, it); } #[inline] - fn visit_ts_object_keyword(&mut self, it: &mut TSObjectKeyword) { - walk_ts_object_keyword(self, it); + fn visit_decorator(&mut self, it: &mut Decorator<'a>) { + walk_decorator(self, it); } #[inline] - fn visit_ts_string_keyword(&mut self, it: &mut TSStringKeyword) { - walk_ts_string_keyword(self, it); + fn visit_binding_pattern(&mut self, it: &mut BindingPattern<'a>) { + walk_binding_pattern(self, it); } #[inline] - fn visit_ts_symbol_keyword(&mut self, it: &mut TSSymbolKeyword) { - walk_ts_symbol_keyword(self, it); + fn visit_binding_pattern_kind(&mut self, it: &mut BindingPatternKind<'a>) { + walk_binding_pattern_kind(self, it); } #[inline] - fn visit_ts_undefined_keyword(&mut self, it: &mut TSUndefinedKeyword) { - walk_ts_undefined_keyword(self, it); + fn visit_object_pattern(&mut self, it: &mut ObjectPattern<'a>) { + walk_object_pattern(self, it); } #[inline] - fn visit_ts_unknown_keyword(&mut self, it: &mut TSUnknownKeyword) { - walk_ts_unknown_keyword(self, it); + fn visit_binding_properties(&mut self, it: &mut Vec<'a, BindingProperty<'a>>) { + walk_binding_properties(self, it); } #[inline] - fn visit_ts_void_keyword(&mut self, it: &mut TSVoidKeyword) { - walk_ts_void_keyword(self, it); + fn visit_binding_property(&mut self, it: &mut BindingProperty<'a>) { + walk_binding_property(self, it); } #[inline] - fn visit_ts_array_type(&mut self, it: &mut TSArrayType<'a>) { - walk_ts_array_type(self, it); + fn visit_property_key(&mut self, it: &mut PropertyKey<'a>) { + walk_property_key(self, it); } #[inline] - fn visit_ts_conditional_type(&mut self, it: &mut TSConditionalType<'a>) { - walk_ts_conditional_type(self, it); + fn visit_private_identifier(&mut self, it: &mut PrivateIdentifier<'a>) { + walk_private_identifier(self, it); } #[inline] - fn visit_ts_constructor_type(&mut self, it: &mut TSConstructorType<'a>) { - walk_ts_constructor_type(self, it); + fn visit_binding_rest_element(&mut self, it: &mut BindingRestElement<'a>) { + walk_binding_rest_element(self, it); } #[inline] - fn visit_ts_type_parameter_declaration(&mut self, it: &mut TSTypeParameterDeclaration<'a>) { - walk_ts_type_parameter_declaration(self, it); + fn visit_array_pattern(&mut self, it: &mut ArrayPattern<'a>) { + walk_array_pattern(self, it); } #[inline] - fn visit_ts_type_parameters(&mut self, it: &mut Vec<'a, TSTypeParameter<'a>>) { - walk_ts_type_parameters(self, it); + fn visit_assignment_pattern(&mut self, it: &mut AssignmentPattern<'a>) { + walk_assignment_pattern(self, it); } #[inline] - fn visit_ts_type_parameter(&mut self, it: &mut TSTypeParameter<'a>) { - walk_ts_type_parameter(self, it); + fn visit_ts_type_annotation(&mut self, it: &mut TSTypeAnnotation<'a>) { + walk_ts_type_annotation(self, it); } #[inline] @@ -1740,89 +1740,54 @@ pub mod walk_mut { }, &it.scope_id, ); - visitor.visit_formal_parameters(&mut it.params); - visitor.visit_function_body(&mut it.body); if let Some(type_parameters) = &mut it.type_parameters { visitor.visit_ts_type_parameter_declaration(type_parameters); } + visitor.visit_formal_parameters(&mut it.params); if let Some(return_type) = &mut it.return_type { visitor.visit_ts_type_annotation(return_type); } + visitor.visit_function_body(&mut it.body); visitor.leave_scope(); visitor.leave_node(kind); } #[inline] - pub fn walk_formal_parameters<'a, V: VisitMut<'a>>( + pub fn walk_ts_type_parameter_declaration<'a, V: VisitMut<'a>>( visitor: &mut V, - it: &mut FormalParameters<'a>, + it: &mut TSTypeParameterDeclaration<'a>, ) { - let kind = AstType::FormalParameters; + let kind = AstType::TSTypeParameterDeclaration; visitor.enter_node(kind); - visitor.visit_formal_parameter_list(&mut it.items); - if let Some(rest) = &mut it.rest { - visitor.visit_binding_rest_element(rest); - } + visitor.visit_ts_type_parameters(&mut it.params); visitor.leave_node(kind); } #[inline] - pub fn walk_formal_parameter_list<'a, V: VisitMut<'a>>( + pub fn walk_ts_type_parameters<'a, V: VisitMut<'a>>( visitor: &mut V, - it: &mut Vec<'a, FormalParameter<'a>>, + it: &mut Vec<'a, TSTypeParameter<'a>>, ) { for el in it.iter_mut() { - visitor.visit_formal_parameter(el); + visitor.visit_ts_type_parameter(el); } } #[inline] - pub fn walk_formal_parameter<'a, V: VisitMut<'a>>( + pub fn walk_ts_type_parameter<'a, V: VisitMut<'a>>( visitor: &mut V, - it: &mut FormalParameter<'a>, + it: &mut TSTypeParameter<'a>, ) { - let kind = AstType::FormalParameter; - visitor.enter_node(kind); - visitor.visit_decorators(&mut it.decorators); - visitor.visit_binding_pattern(&mut it.pattern); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_decorators<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Vec<'a, Decorator<'a>>) { - for el in it.iter_mut() { - visitor.visit_decorator(el); - } - } - - #[inline] - pub fn walk_decorator<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Decorator<'a>) { - let kind = AstType::Decorator; + let kind = AstType::TSTypeParameter; visitor.enter_node(kind); - visitor.visit_expression(&mut it.expression); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_binding_pattern<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut BindingPattern<'a>) { - // NOTE: AstType doesn't exists! - visitor.visit_binding_pattern_kind(&mut it.kind); - if let Some(type_annotation) = &mut it.type_annotation { - visitor.visit_ts_type_annotation(type_annotation); + visitor.visit_binding_identifier(&mut it.name); + if let Some(constraint) = &mut it.constraint { + visitor.visit_ts_type(constraint); } - } - - #[inline] - pub fn walk_binding_pattern_kind<'a, V: VisitMut<'a>>( - visitor: &mut V, - it: &mut BindingPatternKind<'a>, - ) { - match it { - BindingPatternKind::BindingIdentifier(it) => visitor.visit_binding_identifier(it), - BindingPatternKind::ObjectPattern(it) => visitor.visit_object_pattern(it), - BindingPatternKind::ArrayPattern(it) => visitor.visit_array_pattern(it), - BindingPatternKind::AssignmentPattern(it) => visitor.visit_assignment_pattern(it), + if let Some(default) = &mut it.default { + visitor.visit_ts_type(default); } + visitor.leave_node(kind); } #[inline] @@ -1835,106 +1800,6 @@ pub mod walk_mut { visitor.leave_node(kind); } - #[inline] - pub fn walk_object_pattern<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ObjectPattern<'a>) { - let kind = AstType::ObjectPattern; - visitor.enter_node(kind); - visitor.visit_binding_properties(&mut it.properties); - if let Some(rest) = &mut it.rest { - visitor.visit_binding_rest_element(rest); - } - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_binding_properties<'a, V: VisitMut<'a>>( - visitor: &mut V, - it: &mut Vec<'a, BindingProperty<'a>>, - ) { - for el in it.iter_mut() { - visitor.visit_binding_property(el); - } - } - - #[inline] - pub fn walk_binding_property<'a, V: VisitMut<'a>>( - visitor: &mut V, - it: &mut BindingProperty<'a>, - ) { - // NOTE: AstType doesn't exists! - visitor.visit_property_key(&mut it.key); - visitor.visit_binding_pattern(&mut it.value); - } - - #[inline] - pub fn walk_property_key<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut PropertyKey<'a>) { - let kind = AstType::PropertyKey; - visitor.enter_node(kind); - match it { - PropertyKey::StaticIdentifier(it) => visitor.visit_identifier_name(it), - PropertyKey::PrivateIdentifier(it) => visitor.visit_private_identifier(it), - match_expression!(PropertyKey) => visitor.visit_expression(it.to_expression_mut()), - } - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_private_identifier<'a, V: VisitMut<'a>>( - visitor: &mut V, - it: &mut PrivateIdentifier<'a>, - ) { - let kind = AstType::PrivateIdentifier; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_binding_rest_element<'a, V: VisitMut<'a>>( - visitor: &mut V, - it: &mut BindingRestElement<'a>, - ) { - let kind = AstType::BindingRestElement; - visitor.enter_node(kind); - visitor.visit_binding_pattern(&mut it.argument); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_array_pattern<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ArrayPattern<'a>) { - let kind = AstType::ArrayPattern; - visitor.enter_node(kind); - for elements in it.elements.iter_mut().flatten() { - visitor.visit_binding_pattern(elements); - } - if let Some(rest) = &mut it.rest { - visitor.visit_binding_rest_element(rest); - } - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_assignment_pattern<'a, V: VisitMut<'a>>( - visitor: &mut V, - it: &mut AssignmentPattern<'a>, - ) { - let kind = AstType::AssignmentPattern; - visitor.enter_node(kind); - visitor.visit_binding_pattern(&mut it.left); - visitor.visit_expression(&mut it.right); - visitor.leave_node(kind); - } - - #[inline] - pub fn walk_ts_type_annotation<'a, V: VisitMut<'a>>( - visitor: &mut V, - it: &mut TSTypeAnnotation<'a>, - ) { - let kind = AstType::TSTypeAnnotation; - visitor.enter_node(kind); - visitor.visit_ts_type(&mut it.type_annotation); - visitor.leave_node(kind); - } - pub fn walk_ts_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSType<'a>) { match it { TSType::TSAnyKeyword(it) => visitor.visit_ts_any_keyword(it), @@ -2117,40 +1982,175 @@ pub mod walk_mut { } #[inline] - pub fn walk_ts_type_parameter_declaration<'a, V: VisitMut<'a>>( + pub fn walk_formal_parameters<'a, V: VisitMut<'a>>( visitor: &mut V, - it: &mut TSTypeParameterDeclaration<'a>, + it: &mut FormalParameters<'a>, ) { - let kind = AstType::TSTypeParameterDeclaration; + let kind = AstType::FormalParameters; visitor.enter_node(kind); - visitor.visit_ts_type_parameters(&mut it.params); + visitor.visit_formal_parameter_list(&mut it.items); + if let Some(rest) = &mut it.rest { + visitor.visit_binding_rest_element(rest); + } visitor.leave_node(kind); } #[inline] - pub fn walk_ts_type_parameters<'a, V: VisitMut<'a>>( + pub fn walk_formal_parameter_list<'a, V: VisitMut<'a>>( visitor: &mut V, - it: &mut Vec<'a, TSTypeParameter<'a>>, + it: &mut Vec<'a, FormalParameter<'a>>, ) { for el in it.iter_mut() { - visitor.visit_ts_type_parameter(el); + visitor.visit_formal_parameter(el); } } #[inline] - pub fn walk_ts_type_parameter<'a, V: VisitMut<'a>>( + pub fn walk_formal_parameter<'a, V: VisitMut<'a>>( visitor: &mut V, - it: &mut TSTypeParameter<'a>, + it: &mut FormalParameter<'a>, ) { - let kind = AstType::TSTypeParameter; + let kind = AstType::FormalParameter; visitor.enter_node(kind); - visitor.visit_binding_identifier(&mut it.name); - if let Some(constraint) = &mut it.constraint { - visitor.visit_ts_type(constraint); + visitor.visit_decorators(&mut it.decorators); + visitor.visit_binding_pattern(&mut it.pattern); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_decorators<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Vec<'a, Decorator<'a>>) { + for el in it.iter_mut() { + visitor.visit_decorator(el); } - if let Some(default) = &mut it.default { - visitor.visit_ts_type(default); + } + + #[inline] + pub fn walk_decorator<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Decorator<'a>) { + let kind = AstType::Decorator; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_binding_pattern<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut BindingPattern<'a>) { + // NOTE: AstType doesn't exists! + visitor.visit_binding_pattern_kind(&mut it.kind); + if let Some(type_annotation) = &mut it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); } + } + + #[inline] + pub fn walk_binding_pattern_kind<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut BindingPatternKind<'a>, + ) { + match it { + BindingPatternKind::BindingIdentifier(it) => visitor.visit_binding_identifier(it), + BindingPatternKind::ObjectPattern(it) => visitor.visit_object_pattern(it), + BindingPatternKind::ArrayPattern(it) => visitor.visit_array_pattern(it), + BindingPatternKind::AssignmentPattern(it) => visitor.visit_assignment_pattern(it), + } + } + + #[inline] + pub fn walk_object_pattern<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ObjectPattern<'a>) { + let kind = AstType::ObjectPattern; + visitor.enter_node(kind); + visitor.visit_binding_properties(&mut it.properties); + if let Some(rest) = &mut it.rest { + visitor.visit_binding_rest_element(rest); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_binding_properties<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, BindingProperty<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_binding_property(el); + } + } + + #[inline] + pub fn walk_binding_property<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut BindingProperty<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_property_key(&mut it.key); + visitor.visit_binding_pattern(&mut it.value); + } + + #[inline] + pub fn walk_property_key<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut PropertyKey<'a>) { + let kind = AstType::PropertyKey; + visitor.enter_node(kind); + match it { + PropertyKey::StaticIdentifier(it) => visitor.visit_identifier_name(it), + PropertyKey::PrivateIdentifier(it) => visitor.visit_private_identifier(it), + match_expression!(PropertyKey) => visitor.visit_expression(it.to_expression_mut()), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_private_identifier<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut PrivateIdentifier<'a>, + ) { + let kind = AstType::PrivateIdentifier; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_binding_rest_element<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut BindingRestElement<'a>, + ) { + let kind = AstType::BindingRestElement; + visitor.enter_node(kind); + visitor.visit_binding_pattern(&mut it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_array_pattern<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ArrayPattern<'a>) { + let kind = AstType::ArrayPattern; + visitor.enter_node(kind); + for elements in it.elements.iter_mut().flatten() { + visitor.visit_binding_pattern(elements); + } + if let Some(rest) = &mut it.rest { + visitor.visit_binding_rest_element(rest); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_assignment_pattern<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentPattern<'a>, + ) { + let kind = AstType::AssignmentPattern; + visitor.enter_node(kind); + visitor.visit_binding_pattern(&mut it.left); + visitor.visit_expression(&mut it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_annotation<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypeAnnotation<'a>, + ) { + let kind = AstType::TSTypeAnnotation; + visitor.enter_node(kind); + visitor.visit_ts_type(&mut it.type_annotation); visitor.leave_node(kind); } diff --git a/crates/oxc_parser/src/js/arrow.rs b/crates/oxc_parser/src/js/arrow.rs index abfd25628170d..348b58c418629 100644 --- a/crates/oxc_parser/src/js/arrow.rs +++ b/crates/oxc_parser/src/js/arrow.rs @@ -304,10 +304,10 @@ impl<'a> ParserImpl<'a> { self.end_span(span), expression, r#async, - params, - body, type_parameters, + params, return_type, + body, )) } diff --git a/crates/oxc_traverse/src/ancestor.rs b/crates/oxc_traverse/src/ancestor.rs index 2496879aaba6d..292c26992eb5c 100644 --- a/crates/oxc_traverse/src/ancestor.rs +++ b/crates/oxc_traverse/src/ancestor.rs @@ -151,10 +151,10 @@ pub(crate) enum AncestorType { FormalParameterPattern = 119, FunctionBodyDirectives = 120, FunctionBodyStatements = 121, - ArrowFunctionExpressionParams = 122, - ArrowFunctionExpressionBody = 123, - ArrowFunctionExpressionTypeParameters = 124, - ArrowFunctionExpressionReturnType = 125, + ArrowFunctionExpressionTypeParameters = 122, + ArrowFunctionExpressionParams = 123, + ArrowFunctionExpressionReturnType = 124, + ArrowFunctionExpressionBody = 125, YieldExpressionArgument = 126, ClassDecorators = 127, ClassId = 128, @@ -545,14 +545,14 @@ pub enum Ancestor<'a> { AncestorType::FunctionBodyDirectives as u16, FunctionBodyStatements(FunctionBodyWithoutStatements<'a>) = AncestorType::FunctionBodyStatements as u16, - ArrowFunctionExpressionParams(ArrowFunctionExpressionWithoutParams<'a>) = - AncestorType::ArrowFunctionExpressionParams as u16, - ArrowFunctionExpressionBody(ArrowFunctionExpressionWithoutBody<'a>) = - AncestorType::ArrowFunctionExpressionBody as u16, ArrowFunctionExpressionTypeParameters(ArrowFunctionExpressionWithoutTypeParameters<'a>) = AncestorType::ArrowFunctionExpressionTypeParameters as u16, + ArrowFunctionExpressionParams(ArrowFunctionExpressionWithoutParams<'a>) = + AncestorType::ArrowFunctionExpressionParams as u16, ArrowFunctionExpressionReturnType(ArrowFunctionExpressionWithoutReturnType<'a>) = AncestorType::ArrowFunctionExpressionReturnType as u16, + ArrowFunctionExpressionBody(ArrowFunctionExpressionWithoutBody<'a>) = + AncestorType::ArrowFunctionExpressionBody as u16, YieldExpressionArgument(YieldExpressionWithoutArgument<'a>) = AncestorType::YieldExpressionArgument as u16, ClassDecorators(ClassWithoutDecorators<'a>) = AncestorType::ClassDecorators as u16, @@ -1266,10 +1266,10 @@ impl<'a> Ancestor<'a> { pub fn is_arrow_function_expression(&self) -> bool { matches!( self, - Self::ArrowFunctionExpressionParams(_) - | Self::ArrowFunctionExpressionBody(_) - | Self::ArrowFunctionExpressionTypeParameters(_) + Self::ArrowFunctionExpressionTypeParameters(_) + | Self::ArrowFunctionExpressionParams(_) | Self::ArrowFunctionExpressionReturnType(_) + | Self::ArrowFunctionExpressionBody(_) ) } @@ -5856,22 +5856,24 @@ pub(crate) const OFFSET_ARROW_FUNCTION_EXPRESSION_EXPRESSION: usize = offset_of!(ArrowFunctionExpression, expression); pub(crate) const OFFSET_ARROW_FUNCTION_EXPRESSION_ASYNC: usize = offset_of!(ArrowFunctionExpression, r#async); -pub(crate) const OFFSET_ARROW_FUNCTION_EXPRESSION_PARAMS: usize = - offset_of!(ArrowFunctionExpression, params); -pub(crate) const OFFSET_ARROW_FUNCTION_EXPRESSION_BODY: usize = - offset_of!(ArrowFunctionExpression, body); pub(crate) const OFFSET_ARROW_FUNCTION_EXPRESSION_TYPE_PARAMETERS: usize = offset_of!(ArrowFunctionExpression, type_parameters); +pub(crate) const OFFSET_ARROW_FUNCTION_EXPRESSION_PARAMS: usize = + offset_of!(ArrowFunctionExpression, params); pub(crate) const OFFSET_ARROW_FUNCTION_EXPRESSION_RETURN_TYPE: usize = offset_of!(ArrowFunctionExpression, return_type); +pub(crate) const OFFSET_ARROW_FUNCTION_EXPRESSION_BODY: usize = + offset_of!(ArrowFunctionExpression, body); pub(crate) const OFFSET_ARROW_FUNCTION_EXPRESSION_SCOPE_ID: usize = offset_of!(ArrowFunctionExpression, scope_id); #[repr(transparent)] #[derive(Debug)] -pub struct ArrowFunctionExpressionWithoutParams<'a>(pub(crate) *const ArrowFunctionExpression<'a>); +pub struct ArrowFunctionExpressionWithoutTypeParameters<'a>( + pub(crate) *const ArrowFunctionExpression<'a>, +); -impl<'a> ArrowFunctionExpressionWithoutParams<'a> { +impl<'a> ArrowFunctionExpressionWithoutTypeParameters<'a> { #[inline] pub fn span(&self) -> &Span { unsafe { @@ -5895,26 +5897,26 @@ impl<'a> ArrowFunctionExpressionWithoutParams<'a> { } #[inline] - pub fn body(&self) -> &Box<'a, FunctionBody<'a>> { + pub fn params(&self) -> &Box<'a, FormalParameters<'a>> { unsafe { - &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_BODY) - as *const Box<'a, FunctionBody<'a>>) + &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_PARAMS) + as *const Box<'a, FormalParameters<'a>>) } } #[inline] - pub fn type_parameters(&self) -> &Option>> { + pub fn return_type(&self) -> &Option>> { unsafe { - &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_TYPE_PARAMETERS) - as *const Option>>) + &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_RETURN_TYPE) + as *const Option>>) } } #[inline] - pub fn return_type(&self) -> &Option>> { + pub fn body(&self) -> &Box<'a, FunctionBody<'a>> { unsafe { - &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_RETURN_TYPE) - as *const Option>>) + &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_BODY) + as *const Box<'a, FunctionBody<'a>>) } } @@ -5929,9 +5931,9 @@ impl<'a> ArrowFunctionExpressionWithoutParams<'a> { #[repr(transparent)] #[derive(Debug)] -pub struct ArrowFunctionExpressionWithoutBody<'a>(pub(crate) *const ArrowFunctionExpression<'a>); +pub struct ArrowFunctionExpressionWithoutParams<'a>(pub(crate) *const ArrowFunctionExpression<'a>); -impl<'a> ArrowFunctionExpressionWithoutBody<'a> { +impl<'a> ArrowFunctionExpressionWithoutParams<'a> { #[inline] pub fn span(&self) -> &Span { unsafe { @@ -5954,14 +5956,6 @@ impl<'a> ArrowFunctionExpressionWithoutBody<'a> { } } - #[inline] - pub fn params(&self) -> &Box<'a, FormalParameters<'a>> { - unsafe { - &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_PARAMS) - as *const Box<'a, FormalParameters<'a>>) - } - } - #[inline] pub fn type_parameters(&self) -> &Option>> { unsafe { @@ -5978,6 +5972,14 @@ impl<'a> ArrowFunctionExpressionWithoutBody<'a> { } } + #[inline] + pub fn body(&self) -> &Box<'a, FunctionBody<'a>> { + unsafe { + &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_BODY) + as *const Box<'a, FunctionBody<'a>>) + } + } + #[inline] pub fn scope_id(&self) -> &Cell> { unsafe { @@ -5989,11 +5991,11 @@ impl<'a> ArrowFunctionExpressionWithoutBody<'a> { #[repr(transparent)] #[derive(Debug)] -pub struct ArrowFunctionExpressionWithoutTypeParameters<'a>( +pub struct ArrowFunctionExpressionWithoutReturnType<'a>( pub(crate) *const ArrowFunctionExpression<'a>, ); -impl<'a> ArrowFunctionExpressionWithoutTypeParameters<'a> { +impl<'a> ArrowFunctionExpressionWithoutReturnType<'a> { #[inline] pub fn span(&self) -> &Span { unsafe { @@ -6016,6 +6018,14 @@ impl<'a> ArrowFunctionExpressionWithoutTypeParameters<'a> { } } + #[inline] + pub fn type_parameters(&self) -> &Option>> { + unsafe { + &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_TYPE_PARAMETERS) + as *const Option>>) + } + } + #[inline] pub fn params(&self) -> &Box<'a, FormalParameters<'a>> { unsafe { @@ -6032,14 +6042,6 @@ impl<'a> ArrowFunctionExpressionWithoutTypeParameters<'a> { } } - #[inline] - pub fn return_type(&self) -> &Option>> { - unsafe { - &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_RETURN_TYPE) - as *const Option>>) - } - } - #[inline] pub fn scope_id(&self) -> &Cell> { unsafe { @@ -6051,11 +6053,9 @@ impl<'a> ArrowFunctionExpressionWithoutTypeParameters<'a> { #[repr(transparent)] #[derive(Debug)] -pub struct ArrowFunctionExpressionWithoutReturnType<'a>( - pub(crate) *const ArrowFunctionExpression<'a>, -); +pub struct ArrowFunctionExpressionWithoutBody<'a>(pub(crate) *const ArrowFunctionExpression<'a>); -impl<'a> ArrowFunctionExpressionWithoutReturnType<'a> { +impl<'a> ArrowFunctionExpressionWithoutBody<'a> { #[inline] pub fn span(&self) -> &Span { unsafe { @@ -6079,26 +6079,26 @@ impl<'a> ArrowFunctionExpressionWithoutReturnType<'a> { } #[inline] - pub fn params(&self) -> &Box<'a, FormalParameters<'a>> { + pub fn type_parameters(&self) -> &Option>> { unsafe { - &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_PARAMS) - as *const Box<'a, FormalParameters<'a>>) + &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_TYPE_PARAMETERS) + as *const Option>>) } } #[inline] - pub fn body(&self) -> &Box<'a, FunctionBody<'a>> { + pub fn params(&self) -> &Box<'a, FormalParameters<'a>> { unsafe { - &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_BODY) - as *const Box<'a, FunctionBody<'a>>) + &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_PARAMS) + as *const Box<'a, FormalParameters<'a>>) } } #[inline] - pub fn type_parameters(&self) -> &Option>> { + pub fn return_type(&self) -> &Option>> { unsafe { - &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_TYPE_PARAMETERS) - as *const Option>>) + &*((self.0 as *const u8).add(OFFSET_ARROW_FUNCTION_EXPRESSION_RETURN_TYPE) + as *const Option>>) } } diff --git a/crates/oxc_traverse/src/walk.rs b/crates/oxc_traverse/src/walk.rs index b3373c2035472..86a377fe07104 100644 --- a/crates/oxc_traverse/src/walk.rs +++ b/crates/oxc_traverse/src/walk.rs @@ -2392,29 +2392,22 @@ pub(crate) unsafe fn walk_arrow_function_expression<'a, Tr: Traverse<'a>>( ctx.set_current_scope_id(scope_id); } traverser.enter_arrow_function_expression(&mut *node, ctx); - ctx.push_stack(Ancestor::ArrowFunctionExpressionParams( - ancestor::ArrowFunctionExpressionWithoutParams(node), + ctx.push_stack(Ancestor::ArrowFunctionExpressionTypeParameters( + ancestor::ArrowFunctionExpressionWithoutTypeParameters(node), )); - walk_formal_parameters( - traverser, - (&mut **((node as *mut u8).add(ancestor::OFFSET_ARROW_FUNCTION_EXPRESSION_PARAMS) - as *mut Box)) as *mut _, - ctx, - ); - ctx.retag_stack(AncestorType::ArrowFunctionExpressionBody); - walk_function_body( - traverser, - (&mut **((node as *mut u8).add(ancestor::OFFSET_ARROW_FUNCTION_EXPRESSION_BODY) - as *mut Box)) as *mut _, - ctx, - ); if let Some(field) = &mut *((node as *mut u8) .add(ancestor::OFFSET_ARROW_FUNCTION_EXPRESSION_TYPE_PARAMETERS) as *mut Option>) { - ctx.retag_stack(AncestorType::ArrowFunctionExpressionTypeParameters); walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx); } + ctx.retag_stack(AncestorType::ArrowFunctionExpressionParams); + walk_formal_parameters( + traverser, + (&mut **((node as *mut u8).add(ancestor::OFFSET_ARROW_FUNCTION_EXPRESSION_PARAMS) + as *mut Box)) as *mut _, + ctx, + ); if let Some(field) = &mut *((node as *mut u8) .add(ancestor::OFFSET_ARROW_FUNCTION_EXPRESSION_RETURN_TYPE) as *mut Option>) @@ -2422,6 +2415,13 @@ pub(crate) unsafe fn walk_arrow_function_expression<'a, Tr: Traverse<'a>>( ctx.retag_stack(AncestorType::ArrowFunctionExpressionReturnType); walk_ts_type_annotation(traverser, (&mut **field) as *mut _, ctx); } + ctx.retag_stack(AncestorType::ArrowFunctionExpressionBody); + walk_function_body( + traverser, + (&mut **((node as *mut u8).add(ancestor::OFFSET_ARROW_FUNCTION_EXPRESSION_BODY) + as *mut Box)) as *mut _, + ctx, + ); ctx.pop_stack(); traverser.exit_arrow_function_expression(&mut *node, ctx); if let Some(previous_scope_id) = previous_scope_id {