diff --git a/Cargo.lock b/Cargo.lock index cb953b867388..c59cb67f4f2f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1337,6 +1337,7 @@ dependencies = [ name = "oxc_ast_codegen" version = "0.0.0" dependencies = [ + "convert_case", "itertools 0.13.0", "lazy_static", "prettyplease", @@ -1499,7 +1500,7 @@ dependencies = [ [[package]] name = "oxc_linter" -version = "0.5.1" +version = "0.5.2" dependencies = [ "convert_case", "dashmap 6.0.1", @@ -1850,7 +1851,7 @@ dependencies = [ [[package]] name = "oxlint" -version = "0.5.1" +version = "0.5.2" dependencies = [ "bpaf", "glob", diff --git a/apps/oxlint/Cargo.toml b/apps/oxlint/Cargo.toml index b9b57d7c671f..c876c64b520d 100644 --- a/apps/oxlint/Cargo.toml +++ b/apps/oxlint/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "oxlint" -version = "0.5.1" +version = "0.5.2" publish = false authors.workspace = true description.workspace = true diff --git a/crates/oxc_ast/src/ast/js.rs b/crates/oxc_ast/src/ast/js.rs index 075b0578bdd0..99cbfdec5ea3 100644 --- a/crates/oxc_ast/src/ast/js.rs +++ b/crates/oxc_ast/src/ast/js.rs @@ -78,6 +78,7 @@ pub enum Expression<'a> { ChainExpression(Box<'a, ChainExpression<'a>>) = 16, ClassExpression(Box<'a, Class<'a>>) = 17, ConditionalExpression(Box<'a, ConditionalExpression<'a>>) = 18, + #[visit_args(flags = None)] FunctionExpression(Box<'a, Function<'a>>) = 19, ImportExpression(Box<'a, ImportExpression<'a>>) = 20, LogicalExpression(Box<'a, LogicalExpression<'a>>) = 21, @@ -250,6 +251,7 @@ pub enum ArrayExpressionElement<'a> { /// Elision(Elision) = 65, // `Expression` variants added here by `inherit_variants!` macro + // TODO: support for attributes syntax here so we can use `#[visit_as(ExpressionArrayElement)]` @inherit Expression } } @@ -967,6 +969,7 @@ pub struct BlockStatement<'a> { #[cfg_attr(feature = "serialize", serde(untagged))] pub enum Declaration<'a> { VariableDeclaration(Box<'a, VariableDeclaration<'a>>) = 32, + #[visit_args(flags = None)] FunctionDeclaration(Box<'a, Function<'a>>) = 33, ClassDeclaration(Box<'a, Class<'a>>) = 34, UsingDeclaration(Box<'a, UsingDeclaration<'a>>) = 35, @@ -1291,6 +1294,7 @@ pub struct TryStatement<'a> { pub span: Span, pub block: Box<'a, BlockStatement<'a>>, pub handler: Option>>, + #[visit_as(FinallyClause)] pub finalizer: Option>>, } @@ -1340,6 +1344,7 @@ pub struct BindingPattern<'a> { feature = "serialize", tsify(type = "(BindingIdentifier | ObjectPattern | ArrayPattern | AssignmentPattern)") )] + #[span] pub kind: BindingPatternKind<'a>, pub type_annotation: Option>>, pub optional: bool, @@ -1432,7 +1437,7 @@ pub struct BindingRestElement<'a> { #[visited_node] #[scope( // TODO: `ScopeFlags::Function` is not correct if this is a `MethodDefinition` - flags(ScopeFlags::Function), + flags(flags.unwrap_or(ScopeFlags::empty()) | ScopeFlags::Function), strict_if(self.body.as_ref().is_some_and(|body| body.has_use_strict_directive())), )] #[derive(Debug)] @@ -1586,6 +1591,7 @@ pub struct Class<'a> { pub decorators: Vec<'a, Decorator<'a>>, #[scope(enter_before)] pub id: Option>, + #[visit_as(ClassHeritage)] pub super_class: Option>, pub body: Box<'a, ClassBody<'a>>, pub type_parameters: Option>>, @@ -1635,6 +1641,12 @@ pub struct MethodDefinition<'a> { pub span: Span, pub decorators: Vec<'a, Decorator<'a>>, pub key: PropertyKey<'a>, + #[visit_args(flags = Some(match self.kind { + MethodDefinitionKind::Get => ScopeFlags::GetAccessor, + MethodDefinitionKind::Set => ScopeFlags::SetAccessor, + MethodDefinitionKind::Constructor => ScopeFlags::Constructor, + MethodDefinitionKind::Method => ScopeFlags::empty(), + }))] pub value: Box<'a, Function<'a>>, // FunctionExpression pub kind: MethodDefinitionKind, pub computed: bool, @@ -1946,9 +1958,11 @@ inherit_variants! { #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))] #[cfg_attr(feature = "serialize", serde(untagged))] pub enum ExportDefaultDeclarationKind<'a> { + #[visit_args(flags = None)] FunctionDeclaration(Box<'a, Function<'a>>) = 64, ClassDeclaration(Box<'a, Class<'a>>) = 65, + #[visit(ignore)] TSInterfaceDeclaration(Box<'a, TSInterfaceDeclaration<'a>>) = 66, // `Expression` variants added here by `inherit_variants!` macro diff --git a/crates/oxc_ast/src/ast/ts.rs b/crates/oxc_ast/src/ast/ts.rs index af9683a9981d..d174cd563805 100644 --- a/crates/oxc_ast/src/ast/ts.rs +++ b/crates/oxc_ast/src/ast/ts.rs @@ -802,7 +802,7 @@ pub enum TSTypePredicateName<'a> { #[visited_node] #[scope( flags(ScopeFlags::TsModuleBlock), - strict_if(self.body.as_ref().is_some_and(|body| body.is_strict())), + strict_if(self.body.as_ref().is_some_and(TSModuleDeclarationBody::is_strict)), )] #[derive(Debug)] #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))] diff --git a/crates/oxc_ast/src/ast_impl/js.rs b/crates/oxc_ast/src/ast_impl/js.rs index e39c488d59d9..3360d7c2ecaa 100644 --- a/crates/oxc_ast/src/ast_impl/js.rs +++ b/crates/oxc_ast/src/ast_impl/js.rs @@ -1298,6 +1298,12 @@ impl MethodDefinitionKind { } } +impl MethodDefinitionType { + pub fn is_abstract(&self) -> bool { + matches!(self, Self::TSAbstractMethodDefinition) + } +} + impl<'a> PrivateIdentifier<'a> { pub fn new(span: Span, name: Atom<'a>) -> Self { Self { span, name } diff --git a/crates/oxc_ast/src/generated/ast_kind.rs b/crates/oxc_ast/src/generated/ast_kind.rs index d8d04f58ffd2..91ca373eb477 100644 --- a/crates/oxc_ast/src/generated/ast_kind.rs +++ b/crates/oxc_ast/src/generated/ast_kind.rs @@ -71,6 +71,7 @@ pub enum AstType { LabeledStatement, ThrowStatement, TryStatement, + FinallyClause, CatchClause, CatchParameter, DebuggerStatement, @@ -85,6 +86,7 @@ pub enum AstType { ArrowFunctionExpression, YieldExpression, Class, + ClassHeritage, ClassBody, MethodDefinition, PropertyDefinition, @@ -164,8 +166,6 @@ pub enum AstType { JSXSpreadAttribute, JSXIdentifier, JSXText, - FinallyClause, - ClassHeritage, ExpressionArrayElement, } @@ -237,6 +237,7 @@ pub enum AstKind<'a> { LabeledStatement(&'a LabeledStatement<'a>), ThrowStatement(&'a ThrowStatement<'a>), TryStatement(&'a TryStatement<'a>), + FinallyClause(&'a BlockStatement<'a>), CatchClause(&'a CatchClause<'a>), CatchParameter(&'a CatchParameter<'a>), DebuggerStatement(&'a DebuggerStatement), @@ -251,6 +252,7 @@ pub enum AstKind<'a> { ArrowFunctionExpression(&'a ArrowFunctionExpression<'a>), YieldExpression(&'a YieldExpression<'a>), Class(&'a Class<'a>), + ClassHeritage(&'a Expression<'a>), ClassBody(&'a ClassBody<'a>), MethodDefinition(&'a MethodDefinition<'a>), PropertyDefinition(&'a PropertyDefinition<'a>), @@ -330,8 +332,6 @@ pub enum AstKind<'a> { JSXSpreadAttribute(&'a JSXSpreadAttribute<'a>), JSXIdentifier(&'a JSXIdentifier<'a>), JSXText(&'a JSXText<'a>), - FinallyClause(&'a BlockStatement<'a>), - ClassHeritage(&'a Expression<'a>), ExpressionArrayElement(&'a Expression<'a>), } @@ -404,6 +404,7 @@ impl<'a> GetSpan for AstKind<'a> { Self::LabeledStatement(it) => it.span(), Self::ThrowStatement(it) => it.span(), Self::TryStatement(it) => it.span(), + Self::FinallyClause(it) => it.span(), Self::CatchClause(it) => it.span(), Self::CatchParameter(it) => it.span(), Self::DebuggerStatement(it) => it.span(), @@ -418,6 +419,7 @@ impl<'a> GetSpan for AstKind<'a> { Self::ArrowFunctionExpression(it) => it.span(), Self::YieldExpression(it) => it.span(), Self::Class(it) => it.span(), + Self::ClassHeritage(it) => it.span(), Self::ClassBody(it) => it.span(), Self::MethodDefinition(it) => it.span(), Self::PropertyDefinition(it) => it.span(), @@ -497,8 +499,6 @@ impl<'a> GetSpan for AstKind<'a> { Self::JSXSpreadAttribute(it) => it.span(), Self::JSXIdentifier(it) => it.span(), Self::JSXText(it) => it.span(), - Self::FinallyClause(it) => it.span(), - Self::ClassHeritage(it) => it.span(), Self::ExpressionArrayElement(it) => it.span(), } } diff --git a/crates/oxc_ast/src/generated/span.rs b/crates/oxc_ast/src/generated/span.rs index 8bcf4ffe4d46..cdbe45573666 100644 --- a/crates/oxc_ast/src/generated/span.rs +++ b/crates/oxc_ast/src/generated/span.rs @@ -925,6 +925,13 @@ impl GetSpan for DebuggerStatement { } } +impl<'a> GetSpan for BindingPattern<'a> { + #[inline] + fn span(&self) -> Span { + self.kind.span() + } +} + impl<'a> GetSpan for BindingPatternKind<'a> { fn span(&self) -> Span { match self { @@ -2185,9 +2192,3 @@ impl<'a> GetSpan for JSXText<'a> { self.span } } - -impl<'a> GetSpan for BindingPattern<'a> { - fn span(&self) -> Span { - self.kind.span() - } -} diff --git a/crates/oxc_ast/src/generated/visit.rs b/crates/oxc_ast/src/generated/visit.rs new file mode 100644 index 000000000000..de23b063413e --- /dev/null +++ b/crates/oxc_ast/src/generated/visit.rs @@ -0,0 +1,4282 @@ +// Auto-generated code, DO NOT EDIT DIRECTLY! +// To edit this generated file you have to edit `tasks/ast_codegen/src/generators/visit.rs` + +//! Visitor Pattern +//! +//! See: +//! * [visitor pattern](https://rust-unofficial.github.io/patterns/patterns/behavioural/visitor.html) +//! * [rustc visitor](https://github.com/rust-lang/rust/blob/master/compiler/rustc_ast/src/visit.rs) + +#![allow( + unused_variables, + clippy::extra_unused_type_parameters, + clippy::explicit_iter_loop, + clippy::self_named_module_files, + clippy::semicolon_if_nothing_returned, + clippy::match_wildcard_for_single_variants +)] + +use oxc_allocator::Vec; +use oxc_syntax::scope::ScopeFlags; + +use crate::{ast::*, ast_kind::AstKind}; + +use walk::*; + +/// Syntax tree traversal +pub trait Visit<'a>: Sized { + fn enter_node(&mut self, kind: AstKind<'a>) {} + fn leave_node(&mut self, kind: AstKind<'a>) {} + + fn enter_scope(&mut self, flags: ScopeFlags) {} + fn leave_scope(&mut self) {} + + #[inline] + fn alloc(&self, t: &T) -> &'a T { + // SAFETY: + // This should be safe as long as `src` is an reference from the allocator. + // But honestly, I'm not really sure if this is safe. + #[allow(unsafe_code)] + unsafe { + std::mem::transmute(t) + } + } + + #[inline] + fn visit_program(&mut self, it: &Program<'a>) { + walk_program(self, it); + } + + #[inline] + fn visit_directives(&mut self, it: &Vec<'a, Directive<'a>>) { + walk_directives(self, it); + } + + #[inline] + fn visit_directive(&mut self, it: &Directive<'a>) { + walk_directive(self, it); + } + + #[inline] + fn visit_string_literal(&mut self, it: &StringLiteral<'a>) { + walk_string_literal(self, it); + } + + #[inline] + fn visit_hashbang(&mut self, it: &Hashbang<'a>) { + walk_hashbang(self, it); + } + + #[inline] + fn visit_statements(&mut self, it: &Vec<'a, Statement<'a>>) { + walk_statements(self, it); + } + + #[inline] + fn visit_statement(&mut self, it: &Statement<'a>) { + walk_statement(self, it); + } + + #[inline] + fn visit_block_statement(&mut self, it: &BlockStatement<'a>) { + walk_block_statement(self, it); + } + + #[inline] + fn visit_break_statement(&mut self, it: &BreakStatement<'a>) { + walk_break_statement(self, it); + } + + #[inline] + fn visit_label_identifier(&mut self, it: &LabelIdentifier<'a>) { + walk_label_identifier(self, it); + } + + #[inline] + fn visit_continue_statement(&mut self, it: &ContinueStatement<'a>) { + walk_continue_statement(self, it); + } + + #[inline] + fn visit_debugger_statement(&mut self, it: &DebuggerStatement) { + walk_debugger_statement(self, it); + } + + #[inline] + fn visit_do_while_statement(&mut self, it: &DoWhileStatement<'a>) { + walk_do_while_statement(self, it); + } + + #[inline] + fn visit_expression(&mut self, it: &Expression<'a>) { + walk_expression(self, it); + } + + #[inline] + fn visit_boolean_literal(&mut self, it: &BooleanLiteral) { + walk_boolean_literal(self, it); + } + + #[inline] + fn visit_null_literal(&mut self, it: &NullLiteral) { + walk_null_literal(self, it); + } + + #[inline] + fn visit_numeric_literal(&mut self, it: &NumericLiteral<'a>) { + walk_numeric_literal(self, it); + } + + #[inline] + fn visit_big_int_literal(&mut self, it: &BigIntLiteral<'a>) { + walk_big_int_literal(self, it); + } + + #[inline] + fn visit_reg_exp_literal(&mut self, it: &RegExpLiteral<'a>) { + walk_reg_exp_literal(self, it); + } + + #[inline] + fn visit_template_literal(&mut self, it: &TemplateLiteral<'a>) { + walk_template_literal(self, it); + } + + #[inline] + fn visit_template_elements(&mut self, it: &Vec<'a, TemplateElement<'a>>) { + walk_template_elements(self, it); + } + + #[inline] + fn visit_template_element(&mut self, it: &TemplateElement<'a>) { + walk_template_element(self, it); + } + + #[inline] + fn visit_expressions(&mut self, it: &Vec<'a, Expression<'a>>) { + walk_expressions(self, it); + } + + #[inline] + fn visit_identifier_reference(&mut self, it: &IdentifierReference<'a>) { + walk_identifier_reference(self, it); + } + + #[inline] + fn visit_meta_property(&mut self, it: &MetaProperty<'a>) { + walk_meta_property(self, it); + } + + #[inline] + fn visit_identifier_name(&mut self, it: &IdentifierName<'a>) { + walk_identifier_name(self, it); + } + + #[inline] + fn visit_super(&mut self, it: &Super) { + walk_super(self, it); + } + + #[inline] + fn visit_array_expression(&mut self, it: &ArrayExpression<'a>) { + walk_array_expression(self, it); + } + + #[inline] + fn visit_array_expression_elements(&mut self, it: &Vec<'a, ArrayExpressionElement<'a>>) { + walk_array_expression_elements(self, it); + } + + #[inline] + fn visit_array_expression_element(&mut self, it: &ArrayExpressionElement<'a>) { + walk_array_expression_element(self, it); + } + + #[inline] + fn visit_spread_element(&mut self, it: &SpreadElement<'a>) { + walk_spread_element(self, it); + } + + #[inline] + fn visit_elision(&mut self, it: &Elision) { + walk_elision(self, it); + } + + #[inline] + fn visit_expression_array_element(&mut self, it: &Expression<'a>) { + walk_expression_array_element(self, it); + } + + #[inline] + fn visit_arrow_function_expression(&mut self, it: &ArrowFunctionExpression<'a>) { + walk_arrow_function_expression(self, it); + } + + #[inline] + fn visit_formal_parameters(&mut self, it: &FormalParameters<'a>) { + walk_formal_parameters(self, it); + } + + #[inline] + fn visit_formal_parameter_list(&mut self, it: &Vec<'a, FormalParameter<'a>>) { + walk_formal_parameter_list(self, it); + } + + #[inline] + fn visit_formal_parameter(&mut self, it: &FormalParameter<'a>) { + walk_formal_parameter(self, it); + } + + #[inline] + fn visit_binding_pattern(&mut self, it: &BindingPattern<'a>) { + walk_binding_pattern(self, it); + } + + #[inline] + fn visit_binding_pattern_kind(&mut self, it: &BindingPatternKind<'a>) { + walk_binding_pattern_kind(self, it); + } + + #[inline] + fn visit_binding_identifier(&mut self, it: &BindingIdentifier<'a>) { + walk_binding_identifier(self, it); + } + + #[inline] + fn visit_object_pattern(&mut self, it: &ObjectPattern<'a>) { + walk_object_pattern(self, it); + } + + #[inline] + fn visit_binding_properties(&mut self, it: &Vec<'a, BindingProperty<'a>>) { + walk_binding_properties(self, it); + } + + #[inline] + fn visit_binding_property(&mut self, it: &BindingProperty<'a>) { + walk_binding_property(self, it); + } + + #[inline] + fn visit_property_key(&mut self, it: &PropertyKey<'a>) { + walk_property_key(self, it); + } + + #[inline] + fn visit_private_identifier(&mut self, it: &PrivateIdentifier<'a>) { + walk_private_identifier(self, it); + } + + #[inline] + fn visit_binding_rest_element(&mut self, it: &BindingRestElement<'a>) { + walk_binding_rest_element(self, it); + } + + #[inline] + fn visit_array_pattern(&mut self, it: &ArrayPattern<'a>) { + walk_array_pattern(self, it); + } + + #[inline] + fn visit_assignment_pattern(&mut self, it: &AssignmentPattern<'a>) { + walk_assignment_pattern(self, it); + } + + #[inline] + fn visit_ts_type_annotation(&mut self, it: &TSTypeAnnotation<'a>) { + walk_ts_type_annotation(self, it); + } + + #[inline] + fn visit_ts_type(&mut self, it: &TSType<'a>) { + walk_ts_type(self, it); + } + + #[inline] + fn visit_ts_any_keyword(&mut self, it: &TSAnyKeyword) { + walk_ts_any_keyword(self, it); + } + + #[inline] + fn visit_ts_big_int_keyword(&mut self, it: &TSBigIntKeyword) { + walk_ts_big_int_keyword(self, it); + } + + #[inline] + fn visit_ts_boolean_keyword(&mut self, it: &TSBooleanKeyword) { + walk_ts_boolean_keyword(self, it); + } + + #[inline] + fn visit_ts_intrinsic_keyword(&mut self, it: &TSIntrinsicKeyword) { + walk_ts_intrinsic_keyword(self, it); + } + + #[inline] + fn visit_ts_never_keyword(&mut self, it: &TSNeverKeyword) { + walk_ts_never_keyword(self, it); + } + + #[inline] + fn visit_ts_null_keyword(&mut self, it: &TSNullKeyword) { + walk_ts_null_keyword(self, it); + } + + #[inline] + fn visit_ts_number_keyword(&mut self, it: &TSNumberKeyword) { + walk_ts_number_keyword(self, it); + } + + #[inline] + fn visit_ts_object_keyword(&mut self, it: &TSObjectKeyword) { + walk_ts_object_keyword(self, it); + } + + #[inline] + fn visit_ts_string_keyword(&mut self, it: &TSStringKeyword) { + walk_ts_string_keyword(self, it); + } + + #[inline] + fn visit_ts_symbol_keyword(&mut self, it: &TSSymbolKeyword) { + walk_ts_symbol_keyword(self, it); + } + + #[inline] + fn visit_ts_undefined_keyword(&mut self, it: &TSUndefinedKeyword) { + walk_ts_undefined_keyword(self, it); + } + + #[inline] + fn visit_ts_unknown_keyword(&mut self, it: &TSUnknownKeyword) { + walk_ts_unknown_keyword(self, it); + } + + #[inline] + fn visit_ts_void_keyword(&mut self, it: &TSVoidKeyword) { + walk_ts_void_keyword(self, it); + } + + #[inline] + fn visit_ts_array_type(&mut self, it: &TSArrayType<'a>) { + walk_ts_array_type(self, it); + } + + #[inline] + fn visit_ts_conditional_type(&mut self, it: &TSConditionalType<'a>) { + walk_ts_conditional_type(self, it); + } + + #[inline] + fn visit_ts_constructor_type(&mut self, it: &TSConstructorType<'a>) { + walk_ts_constructor_type(self, it); + } + + #[inline] + fn visit_ts_type_parameter_declaration(&mut self, it: &TSTypeParameterDeclaration<'a>) { + walk_ts_type_parameter_declaration(self, it); + } + + #[inline] + fn visit_ts_type_parameters(&mut self, it: &Vec<'a, TSTypeParameter<'a>>) { + walk_ts_type_parameters(self, it); + } + + #[inline] + fn visit_ts_type_parameter(&mut self, it: &TSTypeParameter<'a>) { + walk_ts_type_parameter(self, it); + } + + #[inline] + fn visit_ts_function_type(&mut self, it: &TSFunctionType<'a>) { + walk_ts_function_type(self, it); + } + + #[inline] + fn visit_ts_this_parameter(&mut self, it: &TSThisParameter<'a>) { + walk_ts_this_parameter(self, it); + } + + #[inline] + fn visit_ts_import_type(&mut self, it: &TSImportType<'a>) { + walk_ts_import_type(self, it); + } + + #[inline] + fn visit_ts_type_name(&mut self, it: &TSTypeName<'a>) { + walk_ts_type_name(self, it); + } + + #[inline] + fn visit_ts_qualified_name(&mut self, it: &TSQualifiedName<'a>) { + walk_ts_qualified_name(self, it); + } + + #[inline] + fn visit_ts_import_attributes(&mut self, it: &TSImportAttributes<'a>) { + walk_ts_import_attributes(self, it); + } + + #[inline] + fn visit_ts_import_attribute_list(&mut self, it: &Vec<'a, TSImportAttribute<'a>>) { + walk_ts_import_attribute_list(self, it); + } + + #[inline] + fn visit_ts_import_attribute(&mut self, it: &TSImportAttribute<'a>) { + walk_ts_import_attribute(self, it); + } + + #[inline] + fn visit_ts_import_attribute_name(&mut self, it: &TSImportAttributeName<'a>) { + walk_ts_import_attribute_name(self, it); + } + + #[inline] + fn visit_ts_type_parameter_instantiation(&mut self, it: &TSTypeParameterInstantiation<'a>) { + walk_ts_type_parameter_instantiation(self, it); + } + + #[inline] + fn visit_ts_types(&mut self, it: &Vec<'a, TSType<'a>>) { + walk_ts_types(self, it); + } + + #[inline] + fn visit_ts_indexed_access_type(&mut self, it: &TSIndexedAccessType<'a>) { + walk_ts_indexed_access_type(self, it); + } + + #[inline] + fn visit_ts_infer_type(&mut self, it: &TSInferType<'a>) { + walk_ts_infer_type(self, it); + } + + #[inline] + fn visit_ts_intersection_type(&mut self, it: &TSIntersectionType<'a>) { + walk_ts_intersection_type(self, it); + } + + #[inline] + fn visit_ts_literal_type(&mut self, it: &TSLiteralType<'a>) { + walk_ts_literal_type(self, it); + } + + #[inline] + fn visit_ts_literal(&mut self, it: &TSLiteral<'a>) { + walk_ts_literal(self, it); + } + + #[inline] + fn visit_unary_expression(&mut self, it: &UnaryExpression<'a>) { + walk_unary_expression(self, it); + } + + #[inline] + fn visit_ts_mapped_type(&mut self, it: &TSMappedType<'a>) { + walk_ts_mapped_type(self, it); + } + + #[inline] + fn visit_ts_named_tuple_member(&mut self, it: &TSNamedTupleMember<'a>) { + walk_ts_named_tuple_member(self, it); + } + + #[inline] + fn visit_ts_tuple_element(&mut self, it: &TSTupleElement<'a>) { + walk_ts_tuple_element(self, it); + } + + #[inline] + fn visit_ts_optional_type(&mut self, it: &TSOptionalType<'a>) { + walk_ts_optional_type(self, it); + } + + #[inline] + fn visit_ts_rest_type(&mut self, it: &TSRestType<'a>) { + walk_ts_rest_type(self, it); + } + + #[inline] + fn visit_ts_template_literal_type(&mut self, it: &TSTemplateLiteralType<'a>) { + walk_ts_template_literal_type(self, it); + } + + #[inline] + fn visit_ts_this_type(&mut self, it: &TSThisType) { + walk_ts_this_type(self, it); + } + + #[inline] + fn visit_ts_tuple_type(&mut self, it: &TSTupleType<'a>) { + walk_ts_tuple_type(self, it); + } + + #[inline] + fn visit_ts_tuple_elements(&mut self, it: &Vec<'a, TSTupleElement<'a>>) { + walk_ts_tuple_elements(self, it); + } + + #[inline] + fn visit_ts_type_literal(&mut self, it: &TSTypeLiteral<'a>) { + walk_ts_type_literal(self, it); + } + + #[inline] + fn visit_ts_signatures(&mut self, it: &Vec<'a, TSSignature<'a>>) { + walk_ts_signatures(self, it); + } + + #[inline] + fn visit_ts_signature(&mut self, it: &TSSignature<'a>) { + walk_ts_signature(self, it); + } + + #[inline] + fn visit_ts_index_signature(&mut self, it: &TSIndexSignature<'a>) { + walk_ts_index_signature(self, it); + } + + #[inline] + fn visit_ts_index_signature_names(&mut self, it: &Vec<'a, TSIndexSignatureName<'a>>) { + walk_ts_index_signature_names(self, it); + } + + #[inline] + fn visit_ts_index_signature_name(&mut self, it: &TSIndexSignatureName<'a>) { + walk_ts_index_signature_name(self, it); + } + + #[inline] + fn visit_ts_property_signature(&mut self, it: &TSPropertySignature<'a>) { + walk_ts_property_signature(self, it); + } + + #[inline] + fn visit_ts_call_signature_declaration(&mut self, it: &TSCallSignatureDeclaration<'a>) { + walk_ts_call_signature_declaration(self, it); + } + + #[inline] + fn visit_ts_construct_signature_declaration( + &mut self, + it: &TSConstructSignatureDeclaration<'a>, + ) { + walk_ts_construct_signature_declaration(self, it); + } + + #[inline] + fn visit_ts_method_signature(&mut self, it: &TSMethodSignature<'a>) { + walk_ts_method_signature(self, it); + } + + #[inline] + fn visit_ts_type_operator(&mut self, it: &TSTypeOperator<'a>) { + walk_ts_type_operator(self, it); + } + + #[inline] + fn visit_ts_type_predicate(&mut self, it: &TSTypePredicate<'a>) { + walk_ts_type_predicate(self, it); + } + + #[inline] + fn visit_ts_type_predicate_name(&mut self, it: &TSTypePredicateName<'a>) { + walk_ts_type_predicate_name(self, it); + } + + #[inline] + fn visit_ts_type_query(&mut self, it: &TSTypeQuery<'a>) { + walk_ts_type_query(self, it); + } + + #[inline] + fn visit_ts_type_query_expr_name(&mut self, it: &TSTypeQueryExprName<'a>) { + walk_ts_type_query_expr_name(self, it); + } + + #[inline] + fn visit_ts_type_reference(&mut self, it: &TSTypeReference<'a>) { + walk_ts_type_reference(self, it); + } + + #[inline] + fn visit_ts_union_type(&mut self, it: &TSUnionType<'a>) { + walk_ts_union_type(self, it); + } + + #[inline] + fn visit_ts_parenthesized_type(&mut self, it: &TSParenthesizedType<'a>) { + walk_ts_parenthesized_type(self, it); + } + + #[inline] + fn visit_js_doc_nullable_type(&mut self, it: &JSDocNullableType<'a>) { + walk_js_doc_nullable_type(self, it); + } + + #[inline] + fn visit_js_doc_non_nullable_type(&mut self, it: &JSDocNonNullableType<'a>) { + walk_js_doc_non_nullable_type(self, it); + } + + #[inline] + fn visit_js_doc_unknown_type(&mut self, it: &JSDocUnknownType) { + walk_js_doc_unknown_type(self, it); + } + + #[inline] + fn visit_decorators(&mut self, it: &Vec<'a, Decorator<'a>>) { + walk_decorators(self, it); + } + + #[inline] + fn visit_decorator(&mut self, it: &Decorator<'a>) { + walk_decorator(self, it); + } + + #[inline] + fn visit_function_body(&mut self, it: &FunctionBody<'a>) { + walk_function_body(self, it); + } + + #[inline] + fn visit_assignment_expression(&mut self, it: &AssignmentExpression<'a>) { + walk_assignment_expression(self, it); + } + + #[inline] + fn visit_assignment_target(&mut self, it: &AssignmentTarget<'a>) { + walk_assignment_target(self, it); + } + + #[inline] + fn visit_simple_assignment_target(&mut self, it: &SimpleAssignmentTarget<'a>) { + walk_simple_assignment_target(self, it); + } + + #[inline] + fn visit_ts_as_expression(&mut self, it: &TSAsExpression<'a>) { + walk_ts_as_expression(self, it); + } + + #[inline] + fn visit_ts_satisfies_expression(&mut self, it: &TSSatisfiesExpression<'a>) { + walk_ts_satisfies_expression(self, it); + } + + #[inline] + fn visit_ts_non_null_expression(&mut self, it: &TSNonNullExpression<'a>) { + walk_ts_non_null_expression(self, it); + } + + #[inline] + fn visit_ts_type_assertion(&mut self, it: &TSTypeAssertion<'a>) { + walk_ts_type_assertion(self, it); + } + + #[inline] + fn visit_ts_instantiation_expression(&mut self, it: &TSInstantiationExpression<'a>) { + walk_ts_instantiation_expression(self, it); + } + + #[inline] + fn visit_member_expression(&mut self, it: &MemberExpression<'a>) { + walk_member_expression(self, it); + } + + #[inline] + fn visit_computed_member_expression(&mut self, it: &ComputedMemberExpression<'a>) { + walk_computed_member_expression(self, it); + } + + #[inline] + fn visit_static_member_expression(&mut self, it: &StaticMemberExpression<'a>) { + walk_static_member_expression(self, it); + } + + #[inline] + fn visit_private_field_expression(&mut self, it: &PrivateFieldExpression<'a>) { + walk_private_field_expression(self, it); + } + + #[inline] + fn visit_assignment_target_pattern(&mut self, it: &AssignmentTargetPattern<'a>) { + walk_assignment_target_pattern(self, it); + } + + #[inline] + fn visit_array_assignment_target(&mut self, it: &ArrayAssignmentTarget<'a>) { + walk_array_assignment_target(self, it); + } + + #[inline] + fn visit_assignment_target_maybe_default(&mut self, it: &AssignmentTargetMaybeDefault<'a>) { + walk_assignment_target_maybe_default(self, it); + } + + #[inline] + fn visit_assignment_target_with_default(&mut self, it: &AssignmentTargetWithDefault<'a>) { + walk_assignment_target_with_default(self, it); + } + + #[inline] + fn visit_assignment_target_rest(&mut self, it: &AssignmentTargetRest<'a>) { + walk_assignment_target_rest(self, it); + } + + #[inline] + fn visit_object_assignment_target(&mut self, it: &ObjectAssignmentTarget<'a>) { + walk_object_assignment_target(self, it); + } + + #[inline] + fn visit_assignment_target_properties(&mut self, it: &Vec<'a, AssignmentTargetProperty<'a>>) { + walk_assignment_target_properties(self, it); + } + + #[inline] + fn visit_assignment_target_property(&mut self, it: &AssignmentTargetProperty<'a>) { + walk_assignment_target_property(self, it); + } + + #[inline] + fn visit_assignment_target_property_identifier( + &mut self, + it: &AssignmentTargetPropertyIdentifier<'a>, + ) { + walk_assignment_target_property_identifier(self, it); + } + + #[inline] + fn visit_assignment_target_property_property( + &mut self, + it: &AssignmentTargetPropertyProperty<'a>, + ) { + walk_assignment_target_property_property(self, it); + } + + #[inline] + fn visit_await_expression(&mut self, it: &AwaitExpression<'a>) { + walk_await_expression(self, it); + } + + #[inline] + fn visit_binary_expression(&mut self, it: &BinaryExpression<'a>) { + walk_binary_expression(self, it); + } + + #[inline] + fn visit_call_expression(&mut self, it: &CallExpression<'a>) { + walk_call_expression(self, it); + } + + #[inline] + fn visit_arguments(&mut self, it: &Vec<'a, Argument<'a>>) { + walk_arguments(self, it); + } + + #[inline] + fn visit_argument(&mut self, it: &Argument<'a>) { + walk_argument(self, it); + } + + #[inline] + fn visit_chain_expression(&mut self, it: &ChainExpression<'a>) { + walk_chain_expression(self, it); + } + + #[inline] + fn visit_chain_element(&mut self, it: &ChainElement<'a>) { + walk_chain_element(self, it); + } + + #[inline] + fn visit_class(&mut self, it: &Class<'a>) { + walk_class(self, it); + } + + #[inline] + fn visit_class_heritage(&mut self, it: &Expression<'a>) { + walk_class_heritage(self, it); + } + + #[inline] + fn visit_conditional_expression(&mut self, it: &ConditionalExpression<'a>) { + walk_conditional_expression(self, it); + } + + #[inline] + fn visit_function(&mut self, it: &Function<'a>, flags: Option) { + walk_function(self, it, flags); + } + + #[inline] + fn visit_import_expression(&mut self, it: &ImportExpression<'a>) { + walk_import_expression(self, it); + } + + #[inline] + fn visit_logical_expression(&mut self, it: &LogicalExpression<'a>) { + walk_logical_expression(self, it); + } + + #[inline] + fn visit_new_expression(&mut self, it: &NewExpression<'a>) { + walk_new_expression(self, it); + } + + #[inline] + fn visit_object_expression(&mut self, it: &ObjectExpression<'a>) { + walk_object_expression(self, it); + } + + #[inline] + fn visit_object_property_kinds(&mut self, it: &Vec<'a, ObjectPropertyKind<'a>>) { + walk_object_property_kinds(self, it); + } + + #[inline] + fn visit_object_property_kind(&mut self, it: &ObjectPropertyKind<'a>) { + walk_object_property_kind(self, it); + } + + #[inline] + fn visit_object_property(&mut self, it: &ObjectProperty<'a>) { + walk_object_property(self, it); + } + + #[inline] + fn visit_parenthesized_expression(&mut self, it: &ParenthesizedExpression<'a>) { + walk_parenthesized_expression(self, it); + } + + #[inline] + fn visit_sequence_expression(&mut self, it: &SequenceExpression<'a>) { + walk_sequence_expression(self, it); + } + + #[inline] + fn visit_tagged_template_expression(&mut self, it: &TaggedTemplateExpression<'a>) { + walk_tagged_template_expression(self, it); + } + + #[inline] + fn visit_this_expression(&mut self, it: &ThisExpression) { + walk_this_expression(self, it); + } + + #[inline] + fn visit_update_expression(&mut self, it: &UpdateExpression<'a>) { + walk_update_expression(self, it); + } + + #[inline] + fn visit_yield_expression(&mut self, it: &YieldExpression<'a>) { + walk_yield_expression(self, it); + } + + #[inline] + fn visit_private_in_expression(&mut self, it: &PrivateInExpression<'a>) { + walk_private_in_expression(self, it); + } + + #[inline] + fn visit_jsx_element(&mut self, it: &JSXElement<'a>) { + walk_jsx_element(self, it); + } + + #[inline] + fn visit_jsx_opening_element(&mut self, it: &JSXOpeningElement<'a>) { + walk_jsx_opening_element(self, it); + } + + #[inline] + fn visit_jsx_element_name(&mut self, it: &JSXElementName<'a>) { + walk_jsx_element_name(self, it); + } + + #[inline] + fn visit_jsx_identifier(&mut self, it: &JSXIdentifier<'a>) { + walk_jsx_identifier(self, it); + } + + #[inline] + fn visit_jsx_namespaced_name(&mut self, it: &JSXNamespacedName<'a>) { + walk_jsx_namespaced_name(self, it); + } + + #[inline] + fn visit_jsx_member_expression(&mut self, it: &JSXMemberExpression<'a>) { + walk_jsx_member_expression(self, it); + } + + #[inline] + fn visit_jsx_member_expression_object(&mut self, it: &JSXMemberExpressionObject<'a>) { + walk_jsx_member_expression_object(self, it); + } + + #[inline] + fn visit_jsx_attribute_items(&mut self, it: &Vec<'a, JSXAttributeItem<'a>>) { + walk_jsx_attribute_items(self, it); + } + + #[inline] + fn visit_jsx_attribute_item(&mut self, it: &JSXAttributeItem<'a>) { + walk_jsx_attribute_item(self, it); + } + + #[inline] + fn visit_jsx_attribute(&mut self, it: &JSXAttribute<'a>) { + walk_jsx_attribute(self, it); + } + + #[inline] + fn visit_jsx_attribute_name(&mut self, it: &JSXAttributeName<'a>) { + walk_jsx_attribute_name(self, it); + } + + #[inline] + fn visit_jsx_attribute_value(&mut self, it: &JSXAttributeValue<'a>) { + walk_jsx_attribute_value(self, it); + } + + #[inline] + fn visit_jsx_expression_container(&mut self, it: &JSXExpressionContainer<'a>) { + walk_jsx_expression_container(self, it); + } + + #[inline] + fn visit_jsx_expression(&mut self, it: &JSXExpression<'a>) { + walk_jsx_expression(self, it); + } + + #[inline] + fn visit_jsx_empty_expression(&mut self, it: &JSXEmptyExpression) { + walk_jsx_empty_expression(self, it); + } + + #[inline] + fn visit_jsx_fragment(&mut self, it: &JSXFragment<'a>) { + walk_jsx_fragment(self, it); + } + + #[inline] + fn visit_jsx_children(&mut self, it: &Vec<'a, JSXChild<'a>>) { + walk_jsx_children(self, it); + } + + #[inline] + fn visit_jsx_child(&mut self, it: &JSXChild<'a>) { + walk_jsx_child(self, it); + } + + #[inline] + fn visit_jsx_text(&mut self, it: &JSXText<'a>) { + walk_jsx_text(self, it); + } + + #[inline] + fn visit_jsx_spread_child(&mut self, it: &JSXSpreadChild<'a>) { + walk_jsx_spread_child(self, it); + } + + #[inline] + fn visit_jsx_spread_attribute(&mut self, it: &JSXSpreadAttribute<'a>) { + walk_jsx_spread_attribute(self, it); + } + + #[inline] + fn visit_jsx_closing_element(&mut self, it: &JSXClosingElement<'a>) { + walk_jsx_closing_element(self, it); + } + + #[inline] + fn visit_class_body(&mut self, it: &ClassBody<'a>) { + walk_class_body(self, it); + } + + #[inline] + fn visit_class_elements(&mut self, it: &Vec<'a, ClassElement<'a>>) { + walk_class_elements(self, it); + } + + #[inline] + fn visit_class_element(&mut self, it: &ClassElement<'a>) { + walk_class_element(self, it); + } + + #[inline] + fn visit_static_block(&mut self, it: &StaticBlock<'a>) { + walk_static_block(self, it); + } + + #[inline] + fn visit_method_definition(&mut self, it: &MethodDefinition<'a>) { + walk_method_definition(self, it); + } + + #[inline] + fn visit_property_definition(&mut self, it: &PropertyDefinition<'a>) { + walk_property_definition(self, it); + } + + #[inline] + fn visit_accessor_property(&mut self, it: &AccessorProperty<'a>) { + walk_accessor_property(self, it); + } + + #[inline] + fn visit_ts_class_implementses(&mut self, it: &Vec<'a, TSClassImplements<'a>>) { + walk_ts_class_implementses(self, it); + } + + #[inline] + fn visit_ts_class_implements(&mut self, it: &TSClassImplements<'a>) { + walk_ts_class_implements(self, it); + } + + #[inline] + fn visit_empty_statement(&mut self, it: &EmptyStatement) { + walk_empty_statement(self, it); + } + + #[inline] + fn visit_expression_statement(&mut self, it: &ExpressionStatement<'a>) { + walk_expression_statement(self, it); + } + + #[inline] + fn visit_for_in_statement(&mut self, it: &ForInStatement<'a>) { + walk_for_in_statement(self, it); + } + + #[inline] + fn visit_for_statement_left(&mut self, it: &ForStatementLeft<'a>) { + walk_for_statement_left(self, it); + } + + #[inline] + fn visit_variable_declaration(&mut self, it: &VariableDeclaration<'a>) { + walk_variable_declaration(self, it); + } + + #[inline] + fn visit_variable_declarators(&mut self, it: &Vec<'a, VariableDeclarator<'a>>) { + walk_variable_declarators(self, it); + } + + #[inline] + fn visit_variable_declarator(&mut self, it: &VariableDeclarator<'a>) { + walk_variable_declarator(self, it); + } + + #[inline] + fn visit_using_declaration(&mut self, it: &UsingDeclaration<'a>) { + walk_using_declaration(self, it); + } + + #[inline] + fn visit_for_of_statement(&mut self, it: &ForOfStatement<'a>) { + walk_for_of_statement(self, it); + } + + #[inline] + fn visit_for_statement(&mut self, it: &ForStatement<'a>) { + walk_for_statement(self, it); + } + + #[inline] + fn visit_for_statement_init(&mut self, it: &ForStatementInit<'a>) { + walk_for_statement_init(self, it); + } + + #[inline] + fn visit_if_statement(&mut self, it: &IfStatement<'a>) { + walk_if_statement(self, it); + } + + #[inline] + fn visit_labeled_statement(&mut self, it: &LabeledStatement<'a>) { + walk_labeled_statement(self, it); + } + + #[inline] + fn visit_return_statement(&mut self, it: &ReturnStatement<'a>) { + walk_return_statement(self, it); + } + + #[inline] + fn visit_switch_statement(&mut self, it: &SwitchStatement<'a>) { + walk_switch_statement(self, it); + } + + #[inline] + fn visit_switch_cases(&mut self, it: &Vec<'a, SwitchCase<'a>>) { + walk_switch_cases(self, it); + } + + #[inline] + fn visit_switch_case(&mut self, it: &SwitchCase<'a>) { + walk_switch_case(self, it); + } + + #[inline] + fn visit_throw_statement(&mut self, it: &ThrowStatement<'a>) { + walk_throw_statement(self, it); + } + + #[inline] + fn visit_try_statement(&mut self, it: &TryStatement<'a>) { + walk_try_statement(self, it); + } + + #[inline] + fn visit_catch_clause(&mut self, it: &CatchClause<'a>) { + walk_catch_clause(self, it); + } + + #[inline] + fn visit_catch_parameter(&mut self, it: &CatchParameter<'a>) { + walk_catch_parameter(self, it); + } + + #[inline] + fn visit_finally_clause(&mut self, it: &BlockStatement<'a>) { + walk_finally_clause(self, it); + } + + #[inline] + fn visit_while_statement(&mut self, it: &WhileStatement<'a>) { + walk_while_statement(self, it); + } + + #[inline] + fn visit_with_statement(&mut self, it: &WithStatement<'a>) { + walk_with_statement(self, it); + } + + #[inline] + fn visit_declaration(&mut self, it: &Declaration<'a>) { + walk_declaration(self, it); + } + + #[inline] + fn visit_ts_type_alias_declaration(&mut self, it: &TSTypeAliasDeclaration<'a>) { + walk_ts_type_alias_declaration(self, it); + } + + #[inline] + fn visit_ts_interface_declaration(&mut self, it: &TSInterfaceDeclaration<'a>) { + walk_ts_interface_declaration(self, it); + } + + #[inline] + fn visit_ts_interface_heritages(&mut self, it: &Vec<'a, TSInterfaceHeritage<'a>>) { + walk_ts_interface_heritages(self, it); + } + + #[inline] + fn visit_ts_interface_heritage(&mut self, it: &TSInterfaceHeritage<'a>) { + walk_ts_interface_heritage(self, it); + } + + #[inline] + fn visit_ts_interface_body(&mut self, it: &TSInterfaceBody<'a>) { + walk_ts_interface_body(self, it); + } + + #[inline] + fn visit_ts_enum_declaration(&mut self, it: &TSEnumDeclaration<'a>) { + walk_ts_enum_declaration(self, it); + } + + #[inline] + fn visit_ts_enum_members(&mut self, it: &Vec<'a, TSEnumMember<'a>>) { + walk_ts_enum_members(self, it); + } + + #[inline] + fn visit_ts_enum_member(&mut self, it: &TSEnumMember<'a>) { + walk_ts_enum_member(self, it); + } + + #[inline] + fn visit_ts_enum_member_name(&mut self, it: &TSEnumMemberName<'a>) { + walk_ts_enum_member_name(self, it); + } + + #[inline] + fn visit_ts_module_declaration(&mut self, it: &TSModuleDeclaration<'a>) { + walk_ts_module_declaration(self, it); + } + + #[inline] + fn visit_ts_module_declaration_name(&mut self, it: &TSModuleDeclarationName<'a>) { + walk_ts_module_declaration_name(self, it); + } + + #[inline] + fn visit_ts_module_declaration_body(&mut self, it: &TSModuleDeclarationBody<'a>) { + walk_ts_module_declaration_body(self, it); + } + + #[inline] + fn visit_ts_module_block(&mut self, it: &TSModuleBlock<'a>) { + walk_ts_module_block(self, it); + } + + #[inline] + fn visit_ts_import_equals_declaration(&mut self, it: &TSImportEqualsDeclaration<'a>) { + walk_ts_import_equals_declaration(self, it); + } + + #[inline] + fn visit_ts_module_reference(&mut self, it: &TSModuleReference<'a>) { + walk_ts_module_reference(self, it); + } + + #[inline] + fn visit_ts_external_module_reference(&mut self, it: &TSExternalModuleReference<'a>) { + walk_ts_external_module_reference(self, it); + } + + #[inline] + fn visit_module_declaration(&mut self, it: &ModuleDeclaration<'a>) { + walk_module_declaration(self, it); + } + + #[inline] + fn visit_import_declaration(&mut self, it: &ImportDeclaration<'a>) { + walk_import_declaration(self, it); + } + + #[inline] + fn visit_import_declaration_specifiers( + &mut self, + it: &Vec<'a, ImportDeclarationSpecifier<'a>>, + ) { + walk_import_declaration_specifiers(self, it); + } + + #[inline] + fn visit_import_declaration_specifier(&mut self, it: &ImportDeclarationSpecifier<'a>) { + walk_import_declaration_specifier(self, it); + } + + #[inline] + fn visit_import_specifier(&mut self, it: &ImportSpecifier<'a>) { + walk_import_specifier(self, it); + } + + #[inline] + fn visit_module_export_name(&mut self, it: &ModuleExportName<'a>) { + walk_module_export_name(self, it); + } + + #[inline] + fn visit_import_default_specifier(&mut self, it: &ImportDefaultSpecifier<'a>) { + walk_import_default_specifier(self, it); + } + + #[inline] + fn visit_import_namespace_specifier(&mut self, it: &ImportNamespaceSpecifier<'a>) { + walk_import_namespace_specifier(self, it); + } + + #[inline] + fn visit_with_clause(&mut self, it: &WithClause<'a>) { + walk_with_clause(self, it); + } + + #[inline] + fn visit_import_attributes(&mut self, it: &Vec<'a, ImportAttribute<'a>>) { + walk_import_attributes(self, it); + } + + #[inline] + fn visit_import_attribute(&mut self, it: &ImportAttribute<'a>) { + walk_import_attribute(self, it); + } + + #[inline] + fn visit_import_attribute_key(&mut self, it: &ImportAttributeKey<'a>) { + walk_import_attribute_key(self, it); + } + + #[inline] + fn visit_export_all_declaration(&mut self, it: &ExportAllDeclaration<'a>) { + walk_export_all_declaration(self, it); + } + + #[inline] + fn visit_export_default_declaration(&mut self, it: &ExportDefaultDeclaration<'a>) { + walk_export_default_declaration(self, it); + } + + #[inline] + fn visit_export_default_declaration_kind(&mut self, it: &ExportDefaultDeclarationKind<'a>) { + walk_export_default_declaration_kind(self, it); + } + + #[inline] + fn visit_export_named_declaration(&mut self, it: &ExportNamedDeclaration<'a>) { + walk_export_named_declaration(self, it); + } + + #[inline] + fn visit_export_specifiers(&mut self, it: &Vec<'a, ExportSpecifier<'a>>) { + walk_export_specifiers(self, it); + } + + #[inline] + fn visit_export_specifier(&mut self, it: &ExportSpecifier<'a>) { + walk_export_specifier(self, it); + } + + #[inline] + fn visit_ts_export_assignment(&mut self, it: &TSExportAssignment<'a>) { + walk_ts_export_assignment(self, it); + } + + #[inline] + fn visit_ts_namespace_export_declaration(&mut self, it: &TSNamespaceExportDeclaration<'a>) { + walk_ts_namespace_export_declaration(self, it); + } +} + +pub mod walk { + use super::*; + + #[inline] + pub fn walk_program<'a, V: Visit<'a>>(visitor: &mut V, it: &Program<'a>) { + visitor.enter_scope({ + let mut flags = ScopeFlags::Top; + if it.source_type.is_strict() || it.directives.iter().any(Directive::is_use_strict) { + flags |= ScopeFlags::StrictMode; + } + flags + }); + let kind = AstKind::Program(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_directives(&it.directives); + if let Some(hashbang) = &it.hashbang { + visitor.visit_hashbang(hashbang); + } + visitor.visit_statements(&it.body); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_directives<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, Directive<'a>>) { + for el in it.iter() { + visitor.visit_directive(el); + } + } + + #[inline] + pub fn walk_directive<'a, V: Visit<'a>>(visitor: &mut V, it: &Directive<'a>) { + let kind = AstKind::Directive(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_string_literal(&it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_string_literal<'a, V: Visit<'a>>(visitor: &mut V, it: &StringLiteral<'a>) { + let kind = AstKind::StringLiteral(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_hashbang<'a, V: Visit<'a>>(visitor: &mut V, it: &Hashbang<'a>) { + let kind = AstKind::Hashbang(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_statements<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, Statement<'a>>) { + for el in it.iter() { + visitor.visit_statement(el); + } + } + + pub fn walk_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &Statement<'a>) { + match it { + Statement::BlockStatement(it) => visitor.visit_block_statement(it), + Statement::BreakStatement(it) => visitor.visit_break_statement(it), + Statement::ContinueStatement(it) => visitor.visit_continue_statement(it), + Statement::DebuggerStatement(it) => visitor.visit_debugger_statement(it), + Statement::DoWhileStatement(it) => visitor.visit_do_while_statement(it), + Statement::EmptyStatement(it) => visitor.visit_empty_statement(it), + Statement::ExpressionStatement(it) => visitor.visit_expression_statement(it), + Statement::ForInStatement(it) => visitor.visit_for_in_statement(it), + Statement::ForOfStatement(it) => visitor.visit_for_of_statement(it), + Statement::ForStatement(it) => visitor.visit_for_statement(it), + Statement::IfStatement(it) => visitor.visit_if_statement(it), + Statement::LabeledStatement(it) => visitor.visit_labeled_statement(it), + Statement::ReturnStatement(it) => visitor.visit_return_statement(it), + Statement::SwitchStatement(it) => visitor.visit_switch_statement(it), + Statement::ThrowStatement(it) => visitor.visit_throw_statement(it), + Statement::TryStatement(it) => visitor.visit_try_statement(it), + Statement::WhileStatement(it) => visitor.visit_while_statement(it), + Statement::WithStatement(it) => visitor.visit_with_statement(it), + match_declaration!(Statement) => visitor.visit_declaration(it.to_declaration()), + match_module_declaration!(Statement) => { + visitor.visit_module_declaration(it.to_module_declaration()) + } + } + } + + #[inline] + pub fn walk_block_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &BlockStatement<'a>) { + visitor.enter_scope(ScopeFlags::empty()); + let kind = AstKind::BlockStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_statements(&it.body); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_break_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &BreakStatement<'a>) { + let kind = AstKind::BreakStatement(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(label) = &it.label { + visitor.visit_label_identifier(label); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_label_identifier<'a, V: Visit<'a>>(visitor: &mut V, it: &LabelIdentifier<'a>) { + let kind = AstKind::LabelIdentifier(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_continue_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &ContinueStatement<'a>) { + let kind = AstKind::ContinueStatement(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(label) = &it.label { + visitor.visit_label_identifier(label); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_debugger_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &DebuggerStatement) { + let kind = AstKind::DebuggerStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_do_while_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &DoWhileStatement<'a>) { + let kind = AstKind::DoWhileStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_statement(&it.body); + visitor.visit_expression(&it.test); + visitor.leave_node(kind); + } + + pub fn walk_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &Expression<'a>) { + match it { + Expression::BooleanLiteral(it) => visitor.visit_boolean_literal(it), + Expression::NullLiteral(it) => visitor.visit_null_literal(it), + Expression::NumericLiteral(it) => visitor.visit_numeric_literal(it), + Expression::BigIntLiteral(it) => visitor.visit_big_int_literal(it), + Expression::RegExpLiteral(it) => visitor.visit_reg_exp_literal(it), + Expression::StringLiteral(it) => visitor.visit_string_literal(it), + Expression::TemplateLiteral(it) => visitor.visit_template_literal(it), + Expression::Identifier(it) => visitor.visit_identifier_reference(it), + Expression::MetaProperty(it) => visitor.visit_meta_property(it), + Expression::Super(it) => visitor.visit_super(it), + Expression::ArrayExpression(it) => visitor.visit_array_expression(it), + Expression::ArrowFunctionExpression(it) => visitor.visit_arrow_function_expression(it), + Expression::AssignmentExpression(it) => visitor.visit_assignment_expression(it), + Expression::AwaitExpression(it) => visitor.visit_await_expression(it), + Expression::BinaryExpression(it) => visitor.visit_binary_expression(it), + Expression::CallExpression(it) => visitor.visit_call_expression(it), + Expression::ChainExpression(it) => visitor.visit_chain_expression(it), + Expression::ClassExpression(it) => visitor.visit_class(it), + Expression::ConditionalExpression(it) => visitor.visit_conditional_expression(it), + Expression::FunctionExpression(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + Expression::ImportExpression(it) => visitor.visit_import_expression(it), + Expression::LogicalExpression(it) => visitor.visit_logical_expression(it), + Expression::NewExpression(it) => visitor.visit_new_expression(it), + Expression::ObjectExpression(it) => visitor.visit_object_expression(it), + Expression::ParenthesizedExpression(it) => visitor.visit_parenthesized_expression(it), + Expression::SequenceExpression(it) => visitor.visit_sequence_expression(it), + Expression::TaggedTemplateExpression(it) => { + visitor.visit_tagged_template_expression(it) + } + Expression::ThisExpression(it) => visitor.visit_this_expression(it), + Expression::UnaryExpression(it) => visitor.visit_unary_expression(it), + Expression::UpdateExpression(it) => visitor.visit_update_expression(it), + Expression::YieldExpression(it) => visitor.visit_yield_expression(it), + Expression::PrivateInExpression(it) => visitor.visit_private_in_expression(it), + Expression::JSXElement(it) => visitor.visit_jsx_element(it), + Expression::JSXFragment(it) => visitor.visit_jsx_fragment(it), + Expression::TSAsExpression(it) => visitor.visit_ts_as_expression(it), + Expression::TSSatisfiesExpression(it) => visitor.visit_ts_satisfies_expression(it), + Expression::TSTypeAssertion(it) => visitor.visit_ts_type_assertion(it), + Expression::TSNonNullExpression(it) => visitor.visit_ts_non_null_expression(it), + Expression::TSInstantiationExpression(it) => { + visitor.visit_ts_instantiation_expression(it) + } + match_member_expression!(Expression) => { + visitor.visit_member_expression(it.to_member_expression()) + } + } + } + + #[inline] + pub fn walk_boolean_literal<'a, V: Visit<'a>>(visitor: &mut V, it: &BooleanLiteral) { + let kind = AstKind::BooleanLiteral(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_null_literal<'a, V: Visit<'a>>(visitor: &mut V, it: &NullLiteral) { + let kind = AstKind::NullLiteral(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_numeric_literal<'a, V: Visit<'a>>(visitor: &mut V, it: &NumericLiteral<'a>) { + let kind = AstKind::NumericLiteral(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_big_int_literal<'a, V: Visit<'a>>(visitor: &mut V, it: &BigIntLiteral<'a>) { + let kind = AstKind::BigIntLiteral(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_reg_exp_literal<'a, V: Visit<'a>>(visitor: &mut V, it: &RegExpLiteral<'a>) { + let kind = AstKind::RegExpLiteral(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_template_literal<'a, V: Visit<'a>>(visitor: &mut V, it: &TemplateLiteral<'a>) { + let kind = AstKind::TemplateLiteral(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_template_elements(&it.quasis); + visitor.visit_expressions(&it.expressions); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_template_elements<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, TemplateElement<'a>>, + ) { + for el in it.iter() { + visitor.visit_template_element(el); + } + } + + #[inline] + pub fn walk_template_element<'a, V: Visit<'a>>(visitor: &mut V, it: &TemplateElement<'a>) { + // NOTE: AstKind doesn't exists! + } + + #[inline] + pub fn walk_expressions<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, Expression<'a>>) { + for el in it.iter() { + visitor.visit_expression(el); + } + } + + #[inline] + pub fn walk_identifier_reference<'a, V: Visit<'a>>( + visitor: &mut V, + it: &IdentifierReference<'a>, + ) { + let kind = AstKind::IdentifierReference(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_meta_property<'a, V: Visit<'a>>(visitor: &mut V, it: &MetaProperty<'a>) { + let kind = AstKind::MetaProperty(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_identifier_name(&it.meta); + visitor.visit_identifier_name(&it.property); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_identifier_name<'a, V: Visit<'a>>(visitor: &mut V, it: &IdentifierName<'a>) { + let kind = AstKind::IdentifierName(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_super<'a, V: Visit<'a>>(visitor: &mut V, it: &Super) { + let kind = AstKind::Super(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_array_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &ArrayExpression<'a>) { + let kind = AstKind::ArrayExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_array_expression_elements(&it.elements); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_array_expression_elements<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, ArrayExpressionElement<'a>>, + ) { + for el in it.iter() { + visitor.visit_array_expression_element(el); + } + } + + #[inline] + pub fn walk_array_expression_element<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ArrayExpressionElement<'a>, + ) { + let kind = AstKind::ArrayExpressionElement(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + ArrayExpressionElement::SpreadElement(it) => visitor.visit_spread_element(it), + ArrayExpressionElement::Elision(it) => visitor.visit_elision(it), + match_expression!(ArrayExpressionElement) => { + visitor.visit_expression_array_element(it.to_expression()) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_spread_element<'a, V: Visit<'a>>(visitor: &mut V, it: &SpreadElement<'a>) { + let kind = AstKind::SpreadElement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_elision<'a, V: Visit<'a>>(visitor: &mut V, it: &Elision) { + let kind = AstKind::Elision(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + pub fn walk_expression_array_element<'a, V: Visit<'a>>(visitor: &mut V, it: &Expression<'a>) { + let kind = AstKind::ExpressionArrayElement(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + Expression::BooleanLiteral(it) => visitor.visit_boolean_literal(it), + Expression::NullLiteral(it) => visitor.visit_null_literal(it), + Expression::NumericLiteral(it) => visitor.visit_numeric_literal(it), + Expression::BigIntLiteral(it) => visitor.visit_big_int_literal(it), + Expression::RegExpLiteral(it) => visitor.visit_reg_exp_literal(it), + Expression::StringLiteral(it) => visitor.visit_string_literal(it), + Expression::TemplateLiteral(it) => visitor.visit_template_literal(it), + Expression::Identifier(it) => visitor.visit_identifier_reference(it), + Expression::MetaProperty(it) => visitor.visit_meta_property(it), + Expression::Super(it) => visitor.visit_super(it), + Expression::ArrayExpression(it) => visitor.visit_array_expression(it), + Expression::ArrowFunctionExpression(it) => visitor.visit_arrow_function_expression(it), + Expression::AssignmentExpression(it) => visitor.visit_assignment_expression(it), + Expression::AwaitExpression(it) => visitor.visit_await_expression(it), + Expression::BinaryExpression(it) => visitor.visit_binary_expression(it), + Expression::CallExpression(it) => visitor.visit_call_expression(it), + Expression::ChainExpression(it) => visitor.visit_chain_expression(it), + Expression::ClassExpression(it) => visitor.visit_class(it), + Expression::ConditionalExpression(it) => visitor.visit_conditional_expression(it), + Expression::FunctionExpression(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + Expression::ImportExpression(it) => visitor.visit_import_expression(it), + Expression::LogicalExpression(it) => visitor.visit_logical_expression(it), + Expression::NewExpression(it) => visitor.visit_new_expression(it), + Expression::ObjectExpression(it) => visitor.visit_object_expression(it), + Expression::ParenthesizedExpression(it) => visitor.visit_parenthesized_expression(it), + Expression::SequenceExpression(it) => visitor.visit_sequence_expression(it), + Expression::TaggedTemplateExpression(it) => { + visitor.visit_tagged_template_expression(it) + } + Expression::ThisExpression(it) => visitor.visit_this_expression(it), + Expression::UnaryExpression(it) => visitor.visit_unary_expression(it), + Expression::UpdateExpression(it) => visitor.visit_update_expression(it), + Expression::YieldExpression(it) => visitor.visit_yield_expression(it), + Expression::PrivateInExpression(it) => visitor.visit_private_in_expression(it), + Expression::JSXElement(it) => visitor.visit_jsx_element(it), + Expression::JSXFragment(it) => visitor.visit_jsx_fragment(it), + Expression::TSAsExpression(it) => visitor.visit_ts_as_expression(it), + Expression::TSSatisfiesExpression(it) => visitor.visit_ts_satisfies_expression(it), + Expression::TSTypeAssertion(it) => visitor.visit_ts_type_assertion(it), + Expression::TSNonNullExpression(it) => visitor.visit_ts_non_null_expression(it), + Expression::TSInstantiationExpression(it) => { + visitor.visit_ts_instantiation_expression(it) + } + match_member_expression!(Expression) => { + visitor.visit_member_expression(it.to_member_expression()) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_arrow_function_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ArrowFunctionExpression<'a>, + ) { + visitor.enter_scope({ + let mut flags = ScopeFlags::Function | ScopeFlags::Arrow; + if it.body.has_use_strict_directive() { + flags |= ScopeFlags::StrictMode; + } + flags + }); + let kind = AstKind::ArrowFunctionExpression(visitor.alloc(it)); + visitor.enter_node(kind); + 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); + } + if let Some(return_type) = &it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[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_binding_pattern(&it.pattern); + visitor.visit_decorators(&it.decorators); + 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: &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_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)); + 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_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.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); + } + + pub fn walk_ts_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSType<'a>) { + match it { + TSType::TSAnyKeyword(it) => visitor.visit_ts_any_keyword(it), + TSType::TSBigIntKeyword(it) => visitor.visit_ts_big_int_keyword(it), + TSType::TSBooleanKeyword(it) => visitor.visit_ts_boolean_keyword(it), + TSType::TSIntrinsicKeyword(it) => visitor.visit_ts_intrinsic_keyword(it), + TSType::TSNeverKeyword(it) => visitor.visit_ts_never_keyword(it), + TSType::TSNullKeyword(it) => visitor.visit_ts_null_keyword(it), + TSType::TSNumberKeyword(it) => visitor.visit_ts_number_keyword(it), + TSType::TSObjectKeyword(it) => visitor.visit_ts_object_keyword(it), + TSType::TSStringKeyword(it) => visitor.visit_ts_string_keyword(it), + TSType::TSSymbolKeyword(it) => visitor.visit_ts_symbol_keyword(it), + TSType::TSUndefinedKeyword(it) => visitor.visit_ts_undefined_keyword(it), + TSType::TSUnknownKeyword(it) => visitor.visit_ts_unknown_keyword(it), + TSType::TSVoidKeyword(it) => visitor.visit_ts_void_keyword(it), + TSType::TSArrayType(it) => visitor.visit_ts_array_type(it), + TSType::TSConditionalType(it) => visitor.visit_ts_conditional_type(it), + TSType::TSConstructorType(it) => visitor.visit_ts_constructor_type(it), + TSType::TSFunctionType(it) => visitor.visit_ts_function_type(it), + TSType::TSImportType(it) => visitor.visit_ts_import_type(it), + TSType::TSIndexedAccessType(it) => visitor.visit_ts_indexed_access_type(it), + TSType::TSInferType(it) => visitor.visit_ts_infer_type(it), + TSType::TSIntersectionType(it) => visitor.visit_ts_intersection_type(it), + TSType::TSLiteralType(it) => visitor.visit_ts_literal_type(it), + TSType::TSMappedType(it) => visitor.visit_ts_mapped_type(it), + TSType::TSNamedTupleMember(it) => visitor.visit_ts_named_tuple_member(it), + TSType::TSQualifiedName(it) => visitor.visit_ts_qualified_name(it), + TSType::TSTemplateLiteralType(it) => visitor.visit_ts_template_literal_type(it), + TSType::TSThisType(it) => visitor.visit_ts_this_type(it), + TSType::TSTupleType(it) => visitor.visit_ts_tuple_type(it), + TSType::TSTypeLiteral(it) => visitor.visit_ts_type_literal(it), + TSType::TSTypeOperatorType(it) => visitor.visit_ts_type_operator(it), + TSType::TSTypePredicate(it) => visitor.visit_ts_type_predicate(it), + TSType::TSTypeQuery(it) => visitor.visit_ts_type_query(it), + TSType::TSTypeReference(it) => visitor.visit_ts_type_reference(it), + TSType::TSUnionType(it) => visitor.visit_ts_union_type(it), + TSType::TSParenthesizedType(it) => visitor.visit_ts_parenthesized_type(it), + TSType::JSDocNullableType(it) => visitor.visit_js_doc_nullable_type(it), + TSType::JSDocNonNullableType(it) => visitor.visit_js_doc_non_nullable_type(it), + TSType::JSDocUnknownType(it) => visitor.visit_js_doc_unknown_type(it), + } + } + + #[inline] + pub fn walk_ts_any_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSAnyKeyword) { + let kind = AstKind::TSAnyKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_big_int_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSBigIntKeyword) { + let kind = AstKind::TSBigIntKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_boolean_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSBooleanKeyword) { + let kind = AstKind::TSBooleanKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_intrinsic_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSIntrinsicKeyword) { + let kind = AstKind::TSIntrinsicKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_never_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSNeverKeyword) { + let kind = AstKind::TSNeverKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_null_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSNullKeyword) { + let kind = AstKind::TSNullKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_number_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSNumberKeyword) { + let kind = AstKind::TSNumberKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_object_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSObjectKeyword) { + let kind = AstKind::TSObjectKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_string_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSStringKeyword) { + let kind = AstKind::TSStringKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_symbol_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSSymbolKeyword) { + let kind = AstKind::TSSymbolKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_undefined_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSUndefinedKeyword) { + let kind = AstKind::TSUndefinedKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_unknown_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSUnknownKeyword) { + let kind = AstKind::TSUnknownKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_void_keyword<'a, V: Visit<'a>>(visitor: &mut V, it: &TSVoidKeyword) { + let kind = AstKind::TSVoidKeyword(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_array_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSArrayType<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type(&it.element_type); + } + + #[inline] + pub fn walk_ts_conditional_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSConditionalType<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type(&it.check_type); + visitor.visit_ts_type(&it.extends_type); + visitor.visit_ts_type(&it.true_type); + visitor.visit_ts_type(&it.false_type); + } + + #[inline] + pub fn walk_ts_constructor_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSConstructorType<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_formal_parameters(&it.params); + visitor.visit_ts_type_annotation(&it.return_type); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + } + + #[inline] + pub fn walk_ts_type_parameter_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSTypeParameterDeclaration<'a>, + ) { + let kind = AstKind::TSTypeParameterDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type_parameters(&it.params); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_parameters<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, TSTypeParameter<'a>>, + ) { + for el in it.iter() { + visitor.visit_ts_type_parameter(el); + } + } + + #[inline] + pub fn walk_ts_type_parameter<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeParameter<'a>) { + visitor.enter_scope(ScopeFlags::empty()); + let kind = AstKind::TSTypeParameter(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_identifier(&it.name); + if let Some(constraint) = &it.constraint { + visitor.visit_ts_type(constraint); + } + if let Some(default) = &it.default { + visitor.visit_ts_type(default); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_ts_function_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSFunctionType<'a>) { + // NOTE: AstKind doesn't exists! + if let Some(this_param) = &it.this_param { + visitor.visit_ts_this_parameter(this_param); + } + visitor.visit_formal_parameters(&it.params); + visitor.visit_ts_type_annotation(&it.return_type); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + } + + #[inline] + pub fn walk_ts_this_parameter<'a, V: Visit<'a>>(visitor: &mut V, it: &TSThisParameter<'a>) { + let kind = AstKind::TSThisParameter(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_identifier_name(&it.this); + if let Some(type_annotation) = &it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_import_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSImportType<'a>) { + let kind = AstKind::TSImportType(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type(&it.parameter); + if let Some(qualifier) = &it.qualifier { + visitor.visit_ts_type_name(qualifier); + } + if let Some(attributes) = &it.attributes { + visitor.visit_ts_import_attributes(attributes); + } + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_name<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeName<'a>) { + let kind = AstKind::TSTypeName(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + TSTypeName::IdentifierReference(it) => visitor.visit_identifier_reference(it), + TSTypeName::QualifiedName(it) => visitor.visit_ts_qualified_name(it), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_qualified_name<'a, V: Visit<'a>>(visitor: &mut V, it: &TSQualifiedName<'a>) { + let kind = AstKind::TSQualifiedName(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type_name(&it.left); + visitor.visit_identifier_name(&it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_import_attributes<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSImportAttributes<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_import_attribute_list(&it.elements); + } + + #[inline] + pub fn walk_ts_import_attribute_list<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, TSImportAttribute<'a>>, + ) { + for el in it.iter() { + visitor.visit_ts_import_attribute(el); + } + } + + #[inline] + pub fn walk_ts_import_attribute<'a, V: Visit<'a>>(visitor: &mut V, it: &TSImportAttribute<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_import_attribute_name(&it.name); + visitor.visit_expression(&it.value); + } + + #[inline] + pub fn walk_ts_import_attribute_name<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSImportAttributeName<'a>, + ) { + match it { + TSImportAttributeName::Identifier(it) => visitor.visit_identifier_name(it), + TSImportAttributeName::StringLiteral(it) => visitor.visit_string_literal(it), + } + } + + #[inline] + pub fn walk_ts_type_parameter_instantiation<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSTypeParameterInstantiation<'a>, + ) { + let kind = AstKind::TSTypeParameterInstantiation(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_types(&it.params); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_types<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, TSType<'a>>) { + for el in it.iter() { + visitor.visit_ts_type(el); + } + } + + #[inline] + pub fn walk_ts_indexed_access_type<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSIndexedAccessType<'a>, + ) { + let kind = AstKind::TSIndexedAccessType(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type(&it.object_type); + visitor.visit_ts_type(&it.index_type); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_infer_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSInferType<'a>) { + let kind = AstKind::TSInferType(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type_parameter(&it.type_parameter); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_intersection_type<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSIntersectionType<'a>, + ) { + let kind = AstKind::TSIntersectionType(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_types(&it.types); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_literal_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSLiteralType<'a>) { + let kind = AstKind::TSLiteralType(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_literal(&it.literal); + visitor.leave_node(kind); + } + + pub fn walk_ts_literal<'a, V: Visit<'a>>(visitor: &mut V, it: &TSLiteral<'a>) { + match it { + TSLiteral::BooleanLiteral(it) => visitor.visit_boolean_literal(it), + TSLiteral::NullLiteral(it) => visitor.visit_null_literal(it), + TSLiteral::NumericLiteral(it) => visitor.visit_numeric_literal(it), + TSLiteral::BigIntLiteral(it) => visitor.visit_big_int_literal(it), + TSLiteral::RegExpLiteral(it) => visitor.visit_reg_exp_literal(it), + TSLiteral::StringLiteral(it) => visitor.visit_string_literal(it), + TSLiteral::TemplateLiteral(it) => visitor.visit_template_literal(it), + TSLiteral::UnaryExpression(it) => visitor.visit_unary_expression(it), + } + } + + #[inline] + pub fn walk_unary_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &UnaryExpression<'a>) { + let kind = AstKind::UnaryExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_mapped_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSMappedType<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type_parameter(&it.type_parameter); + if let Some(name_type) = &it.name_type { + visitor.visit_ts_type(name_type); + } + if let Some(type_annotation) = &it.type_annotation { + visitor.visit_ts_type(type_annotation); + } + } + + #[inline] + pub fn walk_ts_named_tuple_member<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSNamedTupleMember<'a>, + ) { + let kind = AstKind::TSNamedTupleMember(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_tuple_element(&it.element_type); + visitor.visit_identifier_name(&it.label); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_tuple_element<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTupleElement<'a>) { + match it { + TSTupleElement::TSOptionalType(it) => visitor.visit_ts_optional_type(it), + TSTupleElement::TSRestType(it) => visitor.visit_ts_rest_type(it), + match_ts_type!(TSTupleElement) => visitor.visit_ts_type(it.to_ts_type()), + } + } + + #[inline] + pub fn walk_ts_optional_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSOptionalType<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type(&it.type_annotation); + } + + #[inline] + pub fn walk_ts_rest_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSRestType<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type(&it.type_annotation); + } + + #[inline] + pub fn walk_ts_template_literal_type<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSTemplateLiteralType<'a>, + ) { + let kind = AstKind::TSTemplateLiteralType(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_template_elements(&it.quasis); + visitor.visit_ts_types(&it.types); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_this_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSThisType) { + let kind = AstKind::TSThisType(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_tuple_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTupleType<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_tuple_elements(&it.element_types); + } + + #[inline] + pub fn walk_ts_tuple_elements<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, TSTupleElement<'a>>, + ) { + for el in it.iter() { + visitor.visit_ts_tuple_element(el); + } + } + + #[inline] + pub fn walk_ts_type_literal<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeLiteral<'a>) { + let kind = AstKind::TSTypeLiteral(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_signatures(&it.members); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_signatures<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, TSSignature<'a>>) { + for el in it.iter() { + visitor.visit_ts_signature(el); + } + } + + #[inline] + pub fn walk_ts_signature<'a, V: Visit<'a>>(visitor: &mut V, it: &TSSignature<'a>) { + match it { + TSSignature::TSIndexSignature(it) => visitor.visit_ts_index_signature(it), + TSSignature::TSPropertySignature(it) => visitor.visit_ts_property_signature(it), + TSSignature::TSCallSignatureDeclaration(it) => { + visitor.visit_ts_call_signature_declaration(it) + } + TSSignature::TSConstructSignatureDeclaration(it) => { + visitor.visit_ts_construct_signature_declaration(it) + } + TSSignature::TSMethodSignature(it) => visitor.visit_ts_method_signature(it), + } + } + + #[inline] + pub fn walk_ts_index_signature<'a, V: Visit<'a>>(visitor: &mut V, it: &TSIndexSignature<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_index_signature_names(&it.parameters); + visitor.visit_ts_type_annotation(&it.type_annotation); + } + + #[inline] + pub fn walk_ts_index_signature_names<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, TSIndexSignatureName<'a>>, + ) { + for el in it.iter() { + visitor.visit_ts_index_signature_name(el); + } + } + + #[inline] + pub fn walk_ts_index_signature_name<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSIndexSignatureName<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type_annotation(&it.type_annotation); + } + + #[inline] + pub fn walk_ts_property_signature<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSPropertySignature<'a>, + ) { + let kind = AstKind::TSPropertySignature(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_property_key(&it.key); + if let Some(type_annotation) = &it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_call_signature_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSCallSignatureDeclaration<'a>, + ) { + // NOTE: AstKind doesn't exists! + if let Some(this_param) = &it.this_param { + visitor.visit_ts_this_parameter(this_param); + } + visitor.visit_formal_parameters(&it.params); + if let Some(return_type) = &it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + } + + #[inline] + pub fn walk_ts_construct_signature_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSConstructSignatureDeclaration<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_formal_parameters(&it.params); + if let Some(return_type) = &it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + } + + #[inline] + pub fn walk_ts_method_signature<'a, V: Visit<'a>>(visitor: &mut V, it: &TSMethodSignature<'a>) { + let kind = AstKind::TSMethodSignature(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_property_key(&it.key); + if let Some(this_param) = &it.this_param { + visitor.visit_ts_this_parameter(this_param); + } + visitor.visit_formal_parameters(&it.params); + if let Some(return_type) = &it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_operator<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeOperator<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type(&it.type_annotation); + } + + #[inline] + pub fn walk_ts_type_predicate<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypePredicate<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type_predicate_name(&it.parameter_name); + if let Some(type_annotation) = &it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); + } + } + + #[inline] + pub fn walk_ts_type_predicate_name<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSTypePredicateName<'a>, + ) { + match it { + TSTypePredicateName::Identifier(it) => visitor.visit_identifier_name(it), + TSTypePredicateName::This(it) => visitor.visit_ts_this_type(it), + } + } + + #[inline] + pub fn walk_ts_type_query<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeQuery<'a>) { + let kind = AstKind::TSTypeQuery(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type_query_expr_name(&it.expr_name); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_query_expr_name<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSTypeQueryExprName<'a>, + ) { + match it { + TSTypeQueryExprName::TSImportType(it) => visitor.visit_ts_import_type(it), + match_ts_type_name!(TSTypeQueryExprName) => { + visitor.visit_ts_type_name(it.to_ts_type_name()) + } + } + } + + #[inline] + pub fn walk_ts_type_reference<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeReference<'a>) { + let kind = AstKind::TSTypeReference(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type_name(&it.type_name); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_union_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSUnionType<'a>) { + let kind = AstKind::TSUnionType(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_types(&it.types); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_parenthesized_type<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSParenthesizedType<'a>, + ) { + let kind = AstKind::TSParenthesizedType(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type(&it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_js_doc_nullable_type<'a, V: Visit<'a>>( + visitor: &mut V, + it: &JSDocNullableType<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type(&it.type_annotation); + } + + #[inline] + pub fn walk_js_doc_non_nullable_type<'a, V: Visit<'a>>( + visitor: &mut V, + it: &JSDocNonNullableType<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_type(&it.type_annotation); + } + + #[inline] + pub fn walk_js_doc_unknown_type<'a, V: Visit<'a>>(visitor: &mut V, it: &JSDocUnknownType) { + // NOTE: AstKind doesn't exists! + } + + #[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_function_body<'a, V: Visit<'a>>(visitor: &mut V, it: &FunctionBody<'a>) { + let kind = AstKind::FunctionBody(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_directives(&it.directives); + visitor.visit_statements(&it.statements); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_assignment_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &AssignmentExpression<'a>, + ) { + let kind = AstKind::AssignmentExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_assignment_target(&it.left); + visitor.visit_expression(&it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_assignment_target<'a, V: Visit<'a>>(visitor: &mut V, it: &AssignmentTarget<'a>) { + let kind = AstKind::AssignmentTarget(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + match_simple_assignment_target!(AssignmentTarget) => { + visitor.visit_simple_assignment_target(it.to_simple_assignment_target()) + } + match_assignment_target_pattern!(AssignmentTarget) => { + visitor.visit_assignment_target_pattern(it.to_assignment_target_pattern()) + } + } + visitor.leave_node(kind); + } + + pub fn walk_simple_assignment_target<'a, V: Visit<'a>>( + visitor: &mut V, + it: &SimpleAssignmentTarget<'a>, + ) { + let kind = AstKind::SimpleAssignmentTarget(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + SimpleAssignmentTarget::AssignmentTargetIdentifier(it) => { + visitor.visit_identifier_reference(it) + } + SimpleAssignmentTarget::TSAsExpression(it) => visitor.visit_ts_as_expression(it), + SimpleAssignmentTarget::TSSatisfiesExpression(it) => { + visitor.visit_ts_satisfies_expression(it) + } + SimpleAssignmentTarget::TSNonNullExpression(it) => { + visitor.visit_ts_non_null_expression(it) + } + SimpleAssignmentTarget::TSTypeAssertion(it) => visitor.visit_ts_type_assertion(it), + SimpleAssignmentTarget::TSInstantiationExpression(it) => { + visitor.visit_ts_instantiation_expression(it) + } + match_member_expression!(SimpleAssignmentTarget) => { + visitor.visit_member_expression(it.to_member_expression()) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_as_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &TSAsExpression<'a>) { + let kind = AstKind::TSAsExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.expression); + visitor.visit_ts_type(&it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_satisfies_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSSatisfiesExpression<'a>, + ) { + let kind = AstKind::TSSatisfiesExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.expression); + visitor.visit_ts_type(&it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_non_null_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSNonNullExpression<'a>, + ) { + let kind = AstKind::TSNonNullExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_assertion<'a, V: Visit<'a>>(visitor: &mut V, it: &TSTypeAssertion<'a>) { + let kind = AstKind::TSTypeAssertion(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.expression); + visitor.visit_ts_type(&it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_instantiation_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSInstantiationExpression<'a>, + ) { + let kind = AstKind::TSInstantiationExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.expression); + visitor.visit_ts_type_parameter_instantiation(&it.type_parameters); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_member_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &MemberExpression<'a>) { + let kind = AstKind::MemberExpression(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + MemberExpression::ComputedMemberExpression(it) => { + visitor.visit_computed_member_expression(it) + } + MemberExpression::StaticMemberExpression(it) => { + visitor.visit_static_member_expression(it) + } + MemberExpression::PrivateFieldExpression(it) => { + visitor.visit_private_field_expression(it) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_computed_member_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ComputedMemberExpression<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_expression(&it.object); + visitor.visit_expression(&it.expression); + } + + #[inline] + pub fn walk_static_member_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &StaticMemberExpression<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_expression(&it.object); + visitor.visit_identifier_name(&it.property); + } + + #[inline] + pub fn walk_private_field_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &PrivateFieldExpression<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_expression(&it.object); + visitor.visit_private_identifier(&it.field); + } + + #[inline] + pub fn walk_assignment_target_pattern<'a, V: Visit<'a>>( + visitor: &mut V, + it: &AssignmentTargetPattern<'a>, + ) { + match it { + AssignmentTargetPattern::ArrayAssignmentTarget(it) => { + visitor.visit_array_assignment_target(it) + } + AssignmentTargetPattern::ObjectAssignmentTarget(it) => { + visitor.visit_object_assignment_target(it) + } + } + } + + #[inline] + pub fn walk_array_assignment_target<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ArrayAssignmentTarget<'a>, + ) { + // NOTE: AstKind doesn't exists! + for elements in it.elements.iter().flatten() { + visitor.visit_assignment_target_maybe_default(elements); + } + if let Some(rest) = &it.rest { + visitor.visit_assignment_target_rest(rest); + } + } + + #[inline] + pub fn walk_assignment_target_maybe_default<'a, V: Visit<'a>>( + visitor: &mut V, + it: &AssignmentTargetMaybeDefault<'a>, + ) { + match it { + AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(it) => { + visitor.visit_assignment_target_with_default(it) + } + match_assignment_target!(AssignmentTargetMaybeDefault) => { + visitor.visit_assignment_target(it.to_assignment_target()) + } + } + } + + #[inline] + pub fn walk_assignment_target_with_default<'a, V: Visit<'a>>( + visitor: &mut V, + it: &AssignmentTargetWithDefault<'a>, + ) { + let kind = AstKind::AssignmentTargetWithDefault(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_assignment_target(&it.binding); + visitor.visit_expression(&it.init); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_assignment_target_rest<'a, V: Visit<'a>>( + visitor: &mut V, + it: &AssignmentTargetRest<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_assignment_target(&it.target); + } + + #[inline] + pub fn walk_object_assignment_target<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ObjectAssignmentTarget<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_assignment_target_properties(&it.properties); + if let Some(rest) = &it.rest { + visitor.visit_assignment_target_rest(rest); + } + } + + #[inline] + pub fn walk_assignment_target_properties<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, AssignmentTargetProperty<'a>>, + ) { + for el in it.iter() { + visitor.visit_assignment_target_property(el); + } + } + + #[inline] + pub fn walk_assignment_target_property<'a, V: Visit<'a>>( + visitor: &mut V, + it: &AssignmentTargetProperty<'a>, + ) { + match it { + AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(it) => { + visitor.visit_assignment_target_property_identifier(it) + } + AssignmentTargetProperty::AssignmentTargetPropertyProperty(it) => { + visitor.visit_assignment_target_property_property(it) + } + } + } + + #[inline] + pub fn walk_assignment_target_property_identifier<'a, V: Visit<'a>>( + visitor: &mut V, + it: &AssignmentTargetPropertyIdentifier<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_identifier_reference(&it.binding); + if let Some(init) = &it.init { + visitor.visit_expression(init); + } + } + + #[inline] + pub fn walk_assignment_target_property_property<'a, V: Visit<'a>>( + visitor: &mut V, + it: &AssignmentTargetPropertyProperty<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_property_key(&it.name); + visitor.visit_assignment_target_maybe_default(&it.binding); + } + + #[inline] + pub fn walk_await_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &AwaitExpression<'a>) { + let kind = AstKind::AwaitExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_binary_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &BinaryExpression<'a>) { + let kind = AstKind::BinaryExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.left); + visitor.visit_expression(&it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_call_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &CallExpression<'a>) { + let kind = AstKind::CallExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_arguments(&it.arguments); + visitor.visit_expression(&it.callee); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_arguments<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, Argument<'a>>) { + for el in it.iter() { + visitor.visit_argument(el); + } + } + + #[inline] + pub fn walk_argument<'a, V: Visit<'a>>(visitor: &mut V, it: &Argument<'a>) { + let kind = AstKind::Argument(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + Argument::SpreadElement(it) => visitor.visit_spread_element(it), + match_expression!(Argument) => visitor.visit_expression(it.to_expression()), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_chain_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &ChainExpression<'a>) { + let kind = AstKind::ChainExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_chain_element(&it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_chain_element<'a, V: Visit<'a>>(visitor: &mut V, it: &ChainElement<'a>) { + match it { + ChainElement::CallExpression(it) => visitor.visit_call_expression(it), + match_member_expression!(ChainElement) => { + visitor.visit_member_expression(it.to_member_expression()) + } + } + } + + pub fn walk_class<'a, V: Visit<'a>>(visitor: &mut V, it: &Class<'a>) { + let kind = AstKind::Class(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_decorators(&it.decorators); + visitor.enter_scope(ScopeFlags::StrictMode); + if let Some(id) = &it.id { + visitor.visit_binding_identifier(id); + } + if let Some(super_class) = &it.super_class { + visitor.visit_class_heritage(super_class); + } + visitor.visit_class_body(&it.body); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + if let Some(super_type_parameters) = &it.super_type_parameters { + visitor.visit_ts_type_parameter_instantiation(super_type_parameters); + } + if let Some(implements) = &it.implements { + visitor.visit_ts_class_implementses(implements); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + pub fn walk_class_heritage<'a, V: Visit<'a>>(visitor: &mut V, it: &Expression<'a>) { + let kind = AstKind::ClassHeritage(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + Expression::BooleanLiteral(it) => visitor.visit_boolean_literal(it), + Expression::NullLiteral(it) => visitor.visit_null_literal(it), + Expression::NumericLiteral(it) => visitor.visit_numeric_literal(it), + Expression::BigIntLiteral(it) => visitor.visit_big_int_literal(it), + Expression::RegExpLiteral(it) => visitor.visit_reg_exp_literal(it), + Expression::StringLiteral(it) => visitor.visit_string_literal(it), + Expression::TemplateLiteral(it) => visitor.visit_template_literal(it), + Expression::Identifier(it) => visitor.visit_identifier_reference(it), + Expression::MetaProperty(it) => visitor.visit_meta_property(it), + Expression::Super(it) => visitor.visit_super(it), + Expression::ArrayExpression(it) => visitor.visit_array_expression(it), + Expression::ArrowFunctionExpression(it) => visitor.visit_arrow_function_expression(it), + Expression::AssignmentExpression(it) => visitor.visit_assignment_expression(it), + Expression::AwaitExpression(it) => visitor.visit_await_expression(it), + Expression::BinaryExpression(it) => visitor.visit_binary_expression(it), + Expression::CallExpression(it) => visitor.visit_call_expression(it), + Expression::ChainExpression(it) => visitor.visit_chain_expression(it), + Expression::ClassExpression(it) => visitor.visit_class(it), + Expression::ConditionalExpression(it) => visitor.visit_conditional_expression(it), + Expression::FunctionExpression(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + Expression::ImportExpression(it) => visitor.visit_import_expression(it), + Expression::LogicalExpression(it) => visitor.visit_logical_expression(it), + Expression::NewExpression(it) => visitor.visit_new_expression(it), + Expression::ObjectExpression(it) => visitor.visit_object_expression(it), + Expression::ParenthesizedExpression(it) => visitor.visit_parenthesized_expression(it), + Expression::SequenceExpression(it) => visitor.visit_sequence_expression(it), + Expression::TaggedTemplateExpression(it) => { + visitor.visit_tagged_template_expression(it) + } + Expression::ThisExpression(it) => visitor.visit_this_expression(it), + Expression::UnaryExpression(it) => visitor.visit_unary_expression(it), + Expression::UpdateExpression(it) => visitor.visit_update_expression(it), + Expression::YieldExpression(it) => visitor.visit_yield_expression(it), + Expression::PrivateInExpression(it) => visitor.visit_private_in_expression(it), + Expression::JSXElement(it) => visitor.visit_jsx_element(it), + Expression::JSXFragment(it) => visitor.visit_jsx_fragment(it), + Expression::TSAsExpression(it) => visitor.visit_ts_as_expression(it), + Expression::TSSatisfiesExpression(it) => visitor.visit_ts_satisfies_expression(it), + Expression::TSTypeAssertion(it) => visitor.visit_ts_type_assertion(it), + Expression::TSNonNullExpression(it) => visitor.visit_ts_non_null_expression(it), + Expression::TSInstantiationExpression(it) => { + visitor.visit_ts_instantiation_expression(it) + } + match_member_expression!(Expression) => { + visitor.visit_member_expression(it.to_member_expression()) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_conditional_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ConditionalExpression<'a>, + ) { + let kind = AstKind::ConditionalExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.test); + visitor.visit_expression(&it.consequent); + visitor.visit_expression(&it.alternate); + visitor.leave_node(kind); + } + + pub fn walk_function<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Function<'a>, + flags: Option, + ) { + visitor.enter_scope({ + let mut flags = flags.unwrap_or(ScopeFlags::empty()) | ScopeFlags::Function; + if it.body.as_ref().is_some_and(|body| body.has_use_strict_directive()) { + flags |= ScopeFlags::StrictMode; + } + flags + }); + let kind = AstKind::Function(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(id) = &it.id { + visitor.visit_binding_identifier(id); + } + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + if let Some(this_param) = &it.this_param { + visitor.visit_ts_this_parameter(this_param); + } + visitor.visit_formal_parameters(&it.params); + if let Some(body) = &it.body { + visitor.visit_function_body(body); + } + if let Some(return_type) = &it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_import_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &ImportExpression<'a>) { + let kind = AstKind::ImportExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.source); + visitor.visit_expressions(&it.arguments); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_logical_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &LogicalExpression<'a>) { + let kind = AstKind::LogicalExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.left); + visitor.visit_expression(&it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_new_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &NewExpression<'a>) { + let kind = AstKind::NewExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.callee); + visitor.visit_arguments(&it.arguments); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_object_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &ObjectExpression<'a>) { + let kind = AstKind::ObjectExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_object_property_kinds(&it.properties); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_object_property_kinds<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, ObjectPropertyKind<'a>>, + ) { + for el in it.iter() { + visitor.visit_object_property_kind(el); + } + } + + #[inline] + pub fn walk_object_property_kind<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ObjectPropertyKind<'a>, + ) { + match it { + ObjectPropertyKind::ObjectProperty(it) => visitor.visit_object_property(it), + ObjectPropertyKind::SpreadProperty(it) => visitor.visit_spread_element(it), + } + } + + #[inline] + pub fn walk_object_property<'a, V: Visit<'a>>(visitor: &mut V, it: &ObjectProperty<'a>) { + let kind = AstKind::ObjectProperty(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_property_key(&it.key); + visitor.visit_expression(&it.value); + if let Some(init) = &it.init { + visitor.visit_expression(init); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_parenthesized_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ParenthesizedExpression<'a>, + ) { + let kind = AstKind::ParenthesizedExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_sequence_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &SequenceExpression<'a>, + ) { + let kind = AstKind::SequenceExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expressions(&it.expressions); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_tagged_template_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TaggedTemplateExpression<'a>, + ) { + let kind = AstKind::TaggedTemplateExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.tag); + visitor.visit_template_literal(&it.quasi); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_this_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &ThisExpression) { + let kind = AstKind::ThisExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_update_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &UpdateExpression<'a>) { + let kind = AstKind::UpdateExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_simple_assignment_target(&it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_yield_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &YieldExpression<'a>) { + let kind = AstKind::YieldExpression(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(argument) = &it.argument { + visitor.visit_expression(argument); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_private_in_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &PrivateInExpression<'a>, + ) { + let kind = AstKind::PrivateInExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_private_identifier(&it.left); + visitor.visit_expression(&it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_element<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXElement<'a>) { + let kind = AstKind::JSXElement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_jsx_opening_element(&it.opening_element); + if let Some(closing_element) = &it.closing_element { + visitor.visit_jsx_closing_element(closing_element); + } + visitor.visit_jsx_children(&it.children); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_opening_element<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXOpeningElement<'a>) { + let kind = AstKind::JSXOpeningElement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_jsx_element_name(&it.name); + visitor.visit_jsx_attribute_items(&it.attributes); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_element_name<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXElementName<'a>) { + let kind = AstKind::JSXElementName(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + JSXElementName::Identifier(it) => visitor.visit_jsx_identifier(it), + JSXElementName::NamespacedName(it) => visitor.visit_jsx_namespaced_name(it), + JSXElementName::MemberExpression(it) => visitor.visit_jsx_member_expression(it), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_identifier<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXIdentifier<'a>) { + let kind = AstKind::JSXIdentifier(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_namespaced_name<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXNamespacedName<'a>) { + let kind = AstKind::JSXNamespacedName(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_jsx_identifier(&it.namespace); + visitor.visit_jsx_identifier(&it.property); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_member_expression<'a, V: Visit<'a>>( + visitor: &mut V, + it: &JSXMemberExpression<'a>, + ) { + let kind = AstKind::JSXMemberExpression(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_jsx_member_expression_object(&it.object); + visitor.visit_jsx_identifier(&it.property); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_member_expression_object<'a, V: Visit<'a>>( + visitor: &mut V, + it: &JSXMemberExpressionObject<'a>, + ) { + let kind = AstKind::JSXMemberExpressionObject(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + JSXMemberExpressionObject::Identifier(it) => visitor.visit_jsx_identifier(it), + JSXMemberExpressionObject::MemberExpression(it) => { + visitor.visit_jsx_member_expression(it) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_attribute_items<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, JSXAttributeItem<'a>>, + ) { + for el in it.iter() { + visitor.visit_jsx_attribute_item(el); + } + } + + #[inline] + pub fn walk_jsx_attribute_item<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXAttributeItem<'a>) { + let kind = AstKind::JSXAttributeItem(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + JSXAttributeItem::Attribute(it) => visitor.visit_jsx_attribute(it), + JSXAttributeItem::SpreadAttribute(it) => visitor.visit_jsx_spread_attribute(it), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_attribute<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXAttribute<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_jsx_attribute_name(&it.name); + if let Some(value) = &it.value { + visitor.visit_jsx_attribute_value(value); + } + } + + #[inline] + pub fn walk_jsx_attribute_name<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXAttributeName<'a>) { + match it { + JSXAttributeName::Identifier(it) => visitor.visit_jsx_identifier(it), + JSXAttributeName::NamespacedName(it) => visitor.visit_jsx_namespaced_name(it), + } + } + + #[inline] + pub fn walk_jsx_attribute_value<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXAttributeValue<'a>) { + match it { + JSXAttributeValue::StringLiteral(it) => visitor.visit_string_literal(it), + JSXAttributeValue::ExpressionContainer(it) => { + visitor.visit_jsx_expression_container(it) + } + JSXAttributeValue::Element(it) => visitor.visit_jsx_element(it), + JSXAttributeValue::Fragment(it) => visitor.visit_jsx_fragment(it), + } + } + + #[inline] + pub fn walk_jsx_expression_container<'a, V: Visit<'a>>( + visitor: &mut V, + it: &JSXExpressionContainer<'a>, + ) { + let kind = AstKind::JSXExpressionContainer(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_jsx_expression(&it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXExpression<'a>) { + match it { + JSXExpression::EmptyExpression(it) => visitor.visit_jsx_empty_expression(it), + match_expression!(JSXExpression) => visitor.visit_expression(it.to_expression()), + } + } + + #[inline] + pub fn walk_jsx_empty_expression<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXEmptyExpression) { + // NOTE: AstKind doesn't exists! + } + + #[inline] + pub fn walk_jsx_fragment<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXFragment<'a>) { + let kind = AstKind::JSXFragment(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_jsx_children(&it.children); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_children<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, JSXChild<'a>>) { + for el in it.iter() { + visitor.visit_jsx_child(el); + } + } + + #[inline] + pub fn walk_jsx_child<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXChild<'a>) { + match it { + JSXChild::Text(it) => visitor.visit_jsx_text(it), + JSXChild::Element(it) => visitor.visit_jsx_element(it), + JSXChild::Fragment(it) => visitor.visit_jsx_fragment(it), + JSXChild::ExpressionContainer(it) => visitor.visit_jsx_expression_container(it), + JSXChild::Spread(it) => visitor.visit_jsx_spread_child(it), + } + } + + #[inline] + pub fn walk_jsx_text<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXText<'a>) { + let kind = AstKind::JSXText(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_spread_child<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXSpreadChild<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_expression(&it.expression); + } + + #[inline] + pub fn walk_jsx_spread_attribute<'a, V: Visit<'a>>( + visitor: &mut V, + it: &JSXSpreadAttribute<'a>, + ) { + let kind = AstKind::JSXSpreadAttribute(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_closing_element<'a, V: Visit<'a>>(visitor: &mut V, it: &JSXClosingElement<'a>) { + let kind = AstKind::JSXClosingElement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_jsx_element_name(&it.name); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_class_body<'a, V: Visit<'a>>(visitor: &mut V, it: &ClassBody<'a>) { + let kind = AstKind::ClassBody(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_class_elements(&it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_class_elements<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, ClassElement<'a>>) { + for el in it.iter() { + visitor.visit_class_element(el); + } + } + + #[inline] + pub fn walk_class_element<'a, V: Visit<'a>>(visitor: &mut V, it: &ClassElement<'a>) { + match it { + ClassElement::StaticBlock(it) => visitor.visit_static_block(it), + ClassElement::MethodDefinition(it) => visitor.visit_method_definition(it), + ClassElement::PropertyDefinition(it) => visitor.visit_property_definition(it), + ClassElement::AccessorProperty(it) => visitor.visit_accessor_property(it), + ClassElement::TSIndexSignature(it) => visitor.visit_ts_index_signature(it), + } + } + + #[inline] + pub fn walk_static_block<'a, V: Visit<'a>>(visitor: &mut V, it: &StaticBlock<'a>) { + visitor.enter_scope(ScopeFlags::ClassStaticBlock); + let kind = AstKind::StaticBlock(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_statements(&it.body); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_method_definition<'a, V: Visit<'a>>(visitor: &mut V, it: &MethodDefinition<'a>) { + let kind = AstKind::MethodDefinition(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_decorators(&it.decorators); + visitor.visit_property_key(&it.key); + { + let flags = Some(match it.kind { + MethodDefinitionKind::Get => ScopeFlags::GetAccessor, + MethodDefinitionKind::Set => ScopeFlags::SetAccessor, + MethodDefinitionKind::Constructor => ScopeFlags::Constructor, + MethodDefinitionKind::Method => ScopeFlags::empty(), + }); + visitor.visit_function(&it.value, flags); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_property_definition<'a, V: Visit<'a>>( + visitor: &mut V, + it: &PropertyDefinition<'a>, + ) { + let kind = AstKind::PropertyDefinition(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_decorators(&it.decorators); + visitor.visit_property_key(&it.key); + if let Some(value) = &it.value { + visitor.visit_expression(value); + } + if let Some(type_annotation) = &it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_accessor_property<'a, V: Visit<'a>>(visitor: &mut V, it: &AccessorProperty<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_property_key(&it.key); + if let Some(value) = &it.value { + visitor.visit_expression(value); + } + visitor.visit_decorators(&it.decorators); + } + + #[inline] + pub fn walk_ts_class_implementses<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, TSClassImplements<'a>>, + ) { + for el in it.iter() { + visitor.visit_ts_class_implements(el); + } + } + + #[inline] + pub fn walk_ts_class_implements<'a, V: Visit<'a>>(visitor: &mut V, it: &TSClassImplements<'a>) { + let kind = AstKind::TSClassImplements(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_type_name(&it.expression); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_empty_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &EmptyStatement) { + let kind = AstKind::EmptyStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_expression_statement<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ExpressionStatement<'a>, + ) { + let kind = AstKind::ExpressionStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_for_in_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &ForInStatement<'a>) { + let scope_events_cond = it.left.is_lexical_declaration(); + if scope_events_cond { + visitor.enter_scope(ScopeFlags::empty()); + } + let kind = AstKind::ForInStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_for_statement_left(&it.left); + visitor.visit_expression(&it.right); + visitor.visit_statement(&it.body); + visitor.leave_node(kind); + if scope_events_cond { + visitor.leave_scope(); + } + } + + #[inline] + pub fn walk_for_statement_left<'a, V: Visit<'a>>(visitor: &mut V, it: &ForStatementLeft<'a>) { + match it { + ForStatementLeft::VariableDeclaration(it) => visitor.visit_variable_declaration(it), + ForStatementLeft::UsingDeclaration(it) => visitor.visit_using_declaration(it), + match_assignment_target!(ForStatementLeft) => { + visitor.visit_assignment_target(it.to_assignment_target()) + } + } + } + + #[inline] + pub fn walk_variable_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &VariableDeclaration<'a>, + ) { + let kind = AstKind::VariableDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_variable_declarators(&it.declarations); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_variable_declarators<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, VariableDeclarator<'a>>, + ) { + for el in it.iter() { + visitor.visit_variable_declarator(el); + } + } + + #[inline] + pub fn walk_variable_declarator<'a, V: Visit<'a>>( + visitor: &mut V, + it: &VariableDeclarator<'a>, + ) { + let kind = AstKind::VariableDeclarator(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_pattern(&it.id); + if let Some(init) = &it.init { + visitor.visit_expression(init); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_using_declaration<'a, V: Visit<'a>>(visitor: &mut V, it: &UsingDeclaration<'a>) { + let kind = AstKind::UsingDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_variable_declarators(&it.declarations); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_for_of_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &ForOfStatement<'a>) { + let scope_events_cond = it.left.is_lexical_declaration(); + if scope_events_cond { + visitor.enter_scope(ScopeFlags::empty()); + } + let kind = AstKind::ForOfStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_for_statement_left(&it.left); + visitor.visit_expression(&it.right); + visitor.visit_statement(&it.body); + visitor.leave_node(kind); + if scope_events_cond { + visitor.leave_scope(); + } + } + + #[inline] + pub fn walk_for_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &ForStatement<'a>) { + let scope_events_cond = + it.init.as_ref().is_some_and(ForStatementInit::is_lexical_declaration); + if scope_events_cond { + visitor.enter_scope(ScopeFlags::empty()); + } + let kind = AstKind::ForStatement(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(init) = &it.init { + visitor.visit_for_statement_init(init); + } + if let Some(test) = &it.test { + visitor.visit_expression(test); + } + if let Some(update) = &it.update { + visitor.visit_expression(update); + } + visitor.visit_statement(&it.body); + visitor.leave_node(kind); + if scope_events_cond { + visitor.leave_scope(); + } + } + + #[inline] + pub fn walk_for_statement_init<'a, V: Visit<'a>>(visitor: &mut V, it: &ForStatementInit<'a>) { + let kind = AstKind::ForStatementInit(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + ForStatementInit::VariableDeclaration(it) => visitor.visit_variable_declaration(it), + ForStatementInit::UsingDeclaration(it) => visitor.visit_using_declaration(it), + match_expression!(ForStatementInit) => visitor.visit_expression(it.to_expression()), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_if_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &IfStatement<'a>) { + let kind = AstKind::IfStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.test); + visitor.visit_statement(&it.consequent); + if let Some(alternate) = &it.alternate { + visitor.visit_statement(alternate); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_labeled_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &LabeledStatement<'a>) { + let kind = AstKind::LabeledStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_label_identifier(&it.label); + visitor.visit_statement(&it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_return_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &ReturnStatement<'a>) { + let kind = AstKind::ReturnStatement(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(argument) = &it.argument { + visitor.visit_expression(argument); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_switch_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &SwitchStatement<'a>) { + let kind = AstKind::SwitchStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.discriminant); + visitor.enter_scope(ScopeFlags::empty()); + visitor.visit_switch_cases(&it.cases); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_switch_cases<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, SwitchCase<'a>>) { + for el in it.iter() { + visitor.visit_switch_case(el); + } + } + + #[inline] + pub fn walk_switch_case<'a, V: Visit<'a>>(visitor: &mut V, it: &SwitchCase<'a>) { + let kind = AstKind::SwitchCase(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(test) = &it.test { + visitor.visit_expression(test); + } + visitor.visit_statements(&it.consequent); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_throw_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &ThrowStatement<'a>) { + let kind = AstKind::ThrowStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_try_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &TryStatement<'a>) { + let kind = AstKind::TryStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_block_statement(&it.block); + if let Some(handler) = &it.handler { + visitor.visit_catch_clause(handler); + } + if let Some(finalizer) = &it.finalizer { + visitor.visit_finally_clause(finalizer); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_catch_clause<'a, V: Visit<'a>>(visitor: &mut V, it: &CatchClause<'a>) { + let scope_events_cond = it.param.is_some(); + if scope_events_cond { + visitor.enter_scope(ScopeFlags::empty()); + } + let kind = AstKind::CatchClause(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(param) = &it.param { + visitor.visit_catch_parameter(param); + } + visitor.visit_block_statement(&it.body); + visitor.leave_node(kind); + if scope_events_cond { + visitor.leave_scope(); + } + } + + #[inline] + pub fn walk_catch_parameter<'a, V: Visit<'a>>(visitor: &mut V, it: &CatchParameter<'a>) { + let kind = AstKind::CatchParameter(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_pattern(&it.pattern); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_finally_clause<'a, V: Visit<'a>>(visitor: &mut V, it: &BlockStatement<'a>) { + visitor.enter_scope(ScopeFlags::empty()); + let kind = AstKind::FinallyClause(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_statements(&it.body); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_while_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &WhileStatement<'a>) { + let kind = AstKind::WhileStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.test); + visitor.visit_statement(&it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_with_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &WithStatement<'a>) { + let kind = AstKind::WithStatement(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.object); + visitor.visit_statement(&it.body); + visitor.leave_node(kind); + } + + pub fn walk_declaration<'a, V: Visit<'a>>(visitor: &mut V, it: &Declaration<'a>) { + match it { + Declaration::VariableDeclaration(it) => visitor.visit_variable_declaration(it), + Declaration::FunctionDeclaration(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + Declaration::ClassDeclaration(it) => visitor.visit_class(it), + Declaration::UsingDeclaration(it) => visitor.visit_using_declaration(it), + Declaration::TSTypeAliasDeclaration(it) => visitor.visit_ts_type_alias_declaration(it), + Declaration::TSInterfaceDeclaration(it) => visitor.visit_ts_interface_declaration(it), + Declaration::TSEnumDeclaration(it) => visitor.visit_ts_enum_declaration(it), + Declaration::TSModuleDeclaration(it) => visitor.visit_ts_module_declaration(it), + Declaration::TSImportEqualsDeclaration(it) => { + visitor.visit_ts_import_equals_declaration(it) + } + } + } + + #[inline] + pub fn walk_ts_type_alias_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSTypeAliasDeclaration<'a>, + ) { + let kind = AstKind::TSTypeAliasDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_identifier(&it.id); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + visitor.visit_ts_type(&it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_interface_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSInterfaceDeclaration<'a>, + ) { + let kind = AstKind::TSInterfaceDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_identifier(&it.id); + if let Some(extends) = &it.extends { + visitor.visit_ts_interface_heritages(extends); + } + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + visitor.visit_ts_interface_body(&it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_interface_heritages<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, TSInterfaceHeritage<'a>>, + ) { + for el in it.iter() { + visitor.visit_ts_interface_heritage(el); + } + } + + #[inline] + pub fn walk_ts_interface_heritage<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSInterfaceHeritage<'a>, + ) { + let kind = AstKind::TSInterfaceHeritage(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_expression(&it.expression); + if let Some(type_parameters) = &it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_interface_body<'a, V: Visit<'a>>(visitor: &mut V, it: &TSInterfaceBody<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_ts_signatures(&it.body); + } + + #[inline] + pub fn walk_ts_enum_declaration<'a, V: Visit<'a>>(visitor: &mut V, it: &TSEnumDeclaration<'a>) { + let kind = AstKind::TSEnumDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_identifier(&it.id); + visitor.enter_scope(ScopeFlags::empty()); + visitor.visit_ts_enum_members(&it.members); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_ts_enum_members<'a, V: Visit<'a>>(visitor: &mut V, it: &Vec<'a, TSEnumMember<'a>>) { + for el in it.iter() { + visitor.visit_ts_enum_member(el); + } + } + + #[inline] + pub fn walk_ts_enum_member<'a, V: Visit<'a>>(visitor: &mut V, it: &TSEnumMember<'a>) { + let kind = AstKind::TSEnumMember(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_enum_member_name(&it.id); + if let Some(initializer) = &it.initializer { + visitor.visit_expression(initializer); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_enum_member_name<'a, V: Visit<'a>>(visitor: &mut V, it: &TSEnumMemberName<'a>) { + match it { + TSEnumMemberName::StaticIdentifier(it) => visitor.visit_identifier_name(it), + TSEnumMemberName::StaticStringLiteral(it) => visitor.visit_string_literal(it), + TSEnumMemberName::StaticNumericLiteral(it) => visitor.visit_numeric_literal(it), + match_expression!(TSEnumMemberName) => visitor.visit_expression(it.to_expression()), + } + } + + #[inline] + pub fn walk_ts_module_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSModuleDeclaration<'a>, + ) { + let kind = AstKind::TSModuleDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_ts_module_declaration_name(&it.id); + visitor.enter_scope({ + let mut flags = ScopeFlags::TsModuleBlock; + if it.body.as_ref().is_some_and(TSModuleDeclarationBody::is_strict) { + flags |= ScopeFlags::StrictMode; + } + flags + }); + if let Some(body) = &it.body { + visitor.visit_ts_module_declaration_body(body); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_ts_module_declaration_name<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSModuleDeclarationName<'a>, + ) { + match it { + TSModuleDeclarationName::Identifier(it) => visitor.visit_identifier_name(it), + TSModuleDeclarationName::StringLiteral(it) => visitor.visit_string_literal(it), + } + } + + #[inline] + pub fn walk_ts_module_declaration_body<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSModuleDeclarationBody<'a>, + ) { + match it { + TSModuleDeclarationBody::TSModuleDeclaration(it) => { + visitor.visit_ts_module_declaration(it) + } + TSModuleDeclarationBody::TSModuleBlock(it) => visitor.visit_ts_module_block(it), + } + } + + #[inline] + pub fn walk_ts_module_block<'a, V: Visit<'a>>(visitor: &mut V, it: &TSModuleBlock<'a>) { + let kind = AstKind::TSModuleBlock(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_directives(&it.directives); + visitor.visit_statements(&it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_import_equals_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSImportEqualsDeclaration<'a>, + ) { + let kind = AstKind::TSImportEqualsDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_identifier(&it.id); + visitor.visit_ts_module_reference(&it.module_reference); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_module_reference<'a, V: Visit<'a>>(visitor: &mut V, it: &TSModuleReference<'a>) { + match it { + TSModuleReference::ExternalModuleReference(it) => { + visitor.visit_ts_external_module_reference(it) + } + match_ts_type_name!(TSModuleReference) => { + visitor.visit_ts_type_name(it.to_ts_type_name()) + } + } + } + + #[inline] + pub fn walk_ts_external_module_reference<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSExternalModuleReference<'a>, + ) { + let kind = AstKind::TSExternalModuleReference(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_string_literal(&it.expression); + visitor.leave_node(kind); + } + + pub fn walk_module_declaration<'a, V: Visit<'a>>(visitor: &mut V, it: &ModuleDeclaration<'a>) { + let kind = AstKind::ModuleDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + match it { + ModuleDeclaration::ImportDeclaration(it) => visitor.visit_import_declaration(it), + ModuleDeclaration::ExportAllDeclaration(it) => visitor.visit_export_all_declaration(it), + ModuleDeclaration::ExportDefaultDeclaration(it) => { + visitor.visit_export_default_declaration(it) + } + ModuleDeclaration::ExportNamedDeclaration(it) => { + visitor.visit_export_named_declaration(it) + } + ModuleDeclaration::TSExportAssignment(it) => visitor.visit_ts_export_assignment(it), + ModuleDeclaration::TSNamespaceExportDeclaration(it) => { + visitor.visit_ts_namespace_export_declaration(it) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_import_declaration<'a, V: Visit<'a>>(visitor: &mut V, it: &ImportDeclaration<'a>) { + let kind = AstKind::ImportDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(specifiers) = &it.specifiers { + visitor.visit_import_declaration_specifiers(specifiers); + } + visitor.visit_string_literal(&it.source); + if let Some(with_clause) = &it.with_clause { + visitor.visit_with_clause(with_clause); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_import_declaration_specifiers<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, ImportDeclarationSpecifier<'a>>, + ) { + for el in it.iter() { + visitor.visit_import_declaration_specifier(el); + } + } + + #[inline] + pub fn walk_import_declaration_specifier<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ImportDeclarationSpecifier<'a>, + ) { + match it { + ImportDeclarationSpecifier::ImportSpecifier(it) => visitor.visit_import_specifier(it), + ImportDeclarationSpecifier::ImportDefaultSpecifier(it) => { + visitor.visit_import_default_specifier(it) + } + ImportDeclarationSpecifier::ImportNamespaceSpecifier(it) => { + visitor.visit_import_namespace_specifier(it) + } + } + } + + #[inline] + pub fn walk_import_specifier<'a, V: Visit<'a>>(visitor: &mut V, it: &ImportSpecifier<'a>) { + let kind = AstKind::ImportSpecifier(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_module_export_name(&it.imported); + visitor.visit_binding_identifier(&it.local); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_module_export_name<'a, V: Visit<'a>>(visitor: &mut V, it: &ModuleExportName<'a>) { + match it { + ModuleExportName::IdentifierName(it) => visitor.visit_identifier_name(it), + ModuleExportName::IdentifierReference(it) => visitor.visit_identifier_reference(it), + ModuleExportName::StringLiteral(it) => visitor.visit_string_literal(it), + } + } + + #[inline] + pub fn walk_import_default_specifier<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ImportDefaultSpecifier<'a>, + ) { + let kind = AstKind::ImportDefaultSpecifier(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_identifier(&it.local); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_import_namespace_specifier<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ImportNamespaceSpecifier<'a>, + ) { + let kind = AstKind::ImportNamespaceSpecifier(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_binding_identifier(&it.local); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_with_clause<'a, V: Visit<'a>>(visitor: &mut V, it: &WithClause<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_identifier_name(&it.attributes_keyword); + visitor.visit_import_attributes(&it.with_entries); + } + + #[inline] + pub fn walk_import_attributes<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, ImportAttribute<'a>>, + ) { + for el in it.iter() { + visitor.visit_import_attribute(el); + } + } + + #[inline] + pub fn walk_import_attribute<'a, V: Visit<'a>>(visitor: &mut V, it: &ImportAttribute<'a>) { + // NOTE: AstKind doesn't exists! + visitor.visit_import_attribute_key(&it.key); + visitor.visit_string_literal(&it.value); + } + + #[inline] + pub fn walk_import_attribute_key<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ImportAttributeKey<'a>, + ) { + match it { + ImportAttributeKey::Identifier(it) => visitor.visit_identifier_name(it), + ImportAttributeKey::StringLiteral(it) => visitor.visit_string_literal(it), + } + } + + #[inline] + pub fn walk_export_all_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ExportAllDeclaration<'a>, + ) { + let kind = AstKind::ExportAllDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(exported) = &it.exported { + visitor.visit_module_export_name(exported); + } + visitor.visit_string_literal(&it.source); + if let Some(with_clause) = &it.with_clause { + visitor.visit_with_clause(with_clause); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_export_default_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ExportDefaultDeclaration<'a>, + ) { + let kind = AstKind::ExportDefaultDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_export_default_declaration_kind(&it.declaration); + visitor.visit_module_export_name(&it.exported); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_export_default_declaration_kind<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ExportDefaultDeclarationKind<'a>, + ) { + match it { + ExportDefaultDeclarationKind::FunctionDeclaration(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + ExportDefaultDeclarationKind::ClassDeclaration(it) => visitor.visit_class(it), + match_expression!(ExportDefaultDeclarationKind) => { + visitor.visit_expression(it.to_expression()) + } + _ => {} + } + } + + #[inline] + pub fn walk_export_named_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &ExportNamedDeclaration<'a>, + ) { + let kind = AstKind::ExportNamedDeclaration(visitor.alloc(it)); + visitor.enter_node(kind); + if let Some(declaration) = &it.declaration { + visitor.visit_declaration(declaration); + } + visitor.visit_export_specifiers(&it.specifiers); + if let Some(source) = &it.source { + visitor.visit_string_literal(source); + } + if let Some(with_clause) = &it.with_clause { + visitor.visit_with_clause(with_clause); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_export_specifiers<'a, V: Visit<'a>>( + visitor: &mut V, + it: &Vec<'a, ExportSpecifier<'a>>, + ) { + for el in it.iter() { + visitor.visit_export_specifier(el); + } + } + + #[inline] + pub fn walk_export_specifier<'a, V: Visit<'a>>(visitor: &mut V, it: &ExportSpecifier<'a>) { + let kind = AstKind::ExportSpecifier(visitor.alloc(it)); + visitor.enter_node(kind); + visitor.visit_module_export_name(&it.local); + visitor.visit_module_export_name(&it.exported); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_export_assignment<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSExportAssignment<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_expression(&it.expression); + } + + #[inline] + pub fn walk_ts_namespace_export_declaration<'a, V: Visit<'a>>( + visitor: &mut V, + it: &TSNamespaceExportDeclaration<'a>, + ) { + // NOTE: AstKind doesn't exists! + visitor.visit_identifier_name(&it.id); + } +} diff --git a/crates/oxc_ast/src/generated/visit_mut.rs b/crates/oxc_ast/src/generated/visit_mut.rs new file mode 100644 index 000000000000..9e72c67fd29b --- /dev/null +++ b/crates/oxc_ast/src/generated/visit_mut.rs @@ -0,0 +1,4520 @@ +// Auto-generated code, DO NOT EDIT DIRECTLY! +// To edit this generated file you have to edit `tasks/ast_codegen/src/generators/visit.rs` + +//! Visitor Pattern +//! +//! See: +//! * [visitor pattern](https://rust-unofficial.github.io/patterns/patterns/behavioural/visitor.html) +//! * [rustc visitor](https://github.com/rust-lang/rust/blob/master/compiler/rustc_ast/src/visit.rs) + +#![allow( + unused_variables, + clippy::extra_unused_type_parameters, + clippy::explicit_iter_loop, + clippy::self_named_module_files, + clippy::semicolon_if_nothing_returned, + clippy::match_wildcard_for_single_variants +)] + +use oxc_allocator::Vec; +use oxc_syntax::scope::ScopeFlags; + +use crate::{ast::*, ast_kind::AstType}; + +use walk_mut::*; + +/// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in place. +pub trait VisitMut<'a>: Sized { + fn enter_node(&mut self, ty: AstType) {} + fn leave_node(&mut self, ty: AstType) {} + + fn enter_scope(&mut self, flags: ScopeFlags) {} + fn leave_scope(&mut self) {} + + #[inline] + fn visit_program(&mut self, it: &mut Program<'a>) { + walk_program(self, it); + } + + #[inline] + fn visit_directives(&mut self, it: &mut Vec<'a, Directive<'a>>) { + walk_directives(self, it); + } + + #[inline] + fn visit_directive(&mut self, it: &mut Directive<'a>) { + walk_directive(self, it); + } + + #[inline] + fn visit_string_literal(&mut self, it: &mut StringLiteral<'a>) { + walk_string_literal(self, it); + } + + #[inline] + fn visit_hashbang(&mut self, it: &mut Hashbang<'a>) { + walk_hashbang(self, it); + } + + #[inline] + fn visit_statements(&mut self, it: &mut Vec<'a, Statement<'a>>) { + walk_statements(self, it); + } + + #[inline] + fn visit_statement(&mut self, it: &mut Statement<'a>) { + walk_statement(self, it); + } + + #[inline] + fn visit_block_statement(&mut self, it: &mut BlockStatement<'a>) { + walk_block_statement(self, it); + } + + #[inline] + fn visit_break_statement(&mut self, it: &mut BreakStatement<'a>) { + walk_break_statement(self, it); + } + + #[inline] + fn visit_label_identifier(&mut self, it: &mut LabelIdentifier<'a>) { + walk_label_identifier(self, it); + } + + #[inline] + fn visit_continue_statement(&mut self, it: &mut ContinueStatement<'a>) { + walk_continue_statement(self, it); + } + + #[inline] + fn visit_debugger_statement(&mut self, it: &mut DebuggerStatement) { + walk_debugger_statement(self, it); + } + + #[inline] + fn visit_do_while_statement(&mut self, it: &mut DoWhileStatement<'a>) { + walk_do_while_statement(self, it); + } + + #[inline] + fn visit_expression(&mut self, it: &mut Expression<'a>) { + walk_expression(self, it); + } + + #[inline] + fn visit_boolean_literal(&mut self, it: &mut BooleanLiteral) { + walk_boolean_literal(self, it); + } + + #[inline] + fn visit_null_literal(&mut self, it: &mut NullLiteral) { + walk_null_literal(self, it); + } + + #[inline] + fn visit_numeric_literal(&mut self, it: &mut NumericLiteral<'a>) { + walk_numeric_literal(self, it); + } + + #[inline] + fn visit_big_int_literal(&mut self, it: &mut BigIntLiteral<'a>) { + walk_big_int_literal(self, it); + } + + #[inline] + fn visit_reg_exp_literal(&mut self, it: &mut RegExpLiteral<'a>) { + walk_reg_exp_literal(self, it); + } + + #[inline] + fn visit_template_literal(&mut self, it: &mut TemplateLiteral<'a>) { + walk_template_literal(self, it); + } + + #[inline] + fn visit_template_elements(&mut self, it: &mut Vec<'a, TemplateElement<'a>>) { + walk_template_elements(self, it); + } + + #[inline] + fn visit_template_element(&mut self, it: &mut TemplateElement<'a>) { + walk_template_element(self, it); + } + + #[inline] + fn visit_expressions(&mut self, it: &mut Vec<'a, Expression<'a>>) { + walk_expressions(self, it); + } + + #[inline] + fn visit_identifier_reference(&mut self, it: &mut IdentifierReference<'a>) { + walk_identifier_reference(self, it); + } + + #[inline] + fn visit_meta_property(&mut self, it: &mut MetaProperty<'a>) { + walk_meta_property(self, it); + } + + #[inline] + fn visit_identifier_name(&mut self, it: &mut IdentifierName<'a>) { + walk_identifier_name(self, it); + } + + #[inline] + fn visit_super(&mut self, it: &mut Super) { + walk_super(self, it); + } + + #[inline] + fn visit_array_expression(&mut self, it: &mut ArrayExpression<'a>) { + walk_array_expression(self, it); + } + + #[inline] + fn visit_array_expression_elements(&mut self, it: &mut Vec<'a, ArrayExpressionElement<'a>>) { + walk_array_expression_elements(self, it); + } + + #[inline] + fn visit_array_expression_element(&mut self, it: &mut ArrayExpressionElement<'a>) { + walk_array_expression_element(self, it); + } + + #[inline] + fn visit_spread_element(&mut self, it: &mut SpreadElement<'a>) { + walk_spread_element(self, it); + } + + #[inline] + fn visit_elision(&mut self, it: &mut Elision) { + walk_elision(self, it); + } + + #[inline] + fn visit_expression_array_element(&mut self, it: &mut Expression<'a>) { + walk_expression_array_element(self, it); + } + + #[inline] + fn visit_arrow_function_expression(&mut self, it: &mut ArrowFunctionExpression<'a>) { + walk_arrow_function_expression(self, it); + } + + #[inline] + fn visit_formal_parameters(&mut self, it: &mut FormalParameters<'a>) { + walk_formal_parameters(self, it); + } + + #[inline] + fn visit_formal_parameter_list(&mut self, it: &mut Vec<'a, FormalParameter<'a>>) { + walk_formal_parameter_list(self, it); + } + + #[inline] + fn visit_formal_parameter(&mut self, it: &mut FormalParameter<'a>) { + walk_formal_parameter(self, it); + } + + #[inline] + fn visit_binding_pattern(&mut self, it: &mut BindingPattern<'a>) { + walk_binding_pattern(self, it); + } + + #[inline] + fn visit_binding_pattern_kind(&mut self, it: &mut BindingPatternKind<'a>) { + walk_binding_pattern_kind(self, it); + } + + #[inline] + fn visit_binding_identifier(&mut self, it: &mut BindingIdentifier<'a>) { + walk_binding_identifier(self, it); + } + + #[inline] + fn visit_object_pattern(&mut self, it: &mut ObjectPattern<'a>) { + walk_object_pattern(self, it); + } + + #[inline] + fn visit_binding_properties(&mut self, it: &mut Vec<'a, BindingProperty<'a>>) { + walk_binding_properties(self, it); + } + + #[inline] + fn visit_binding_property(&mut self, it: &mut BindingProperty<'a>) { + walk_binding_property(self, it); + } + + #[inline] + fn visit_property_key(&mut self, it: &mut PropertyKey<'a>) { + walk_property_key(self, it); + } + + #[inline] + fn visit_private_identifier(&mut self, it: &mut PrivateIdentifier<'a>) { + walk_private_identifier(self, it); + } + + #[inline] + fn visit_binding_rest_element(&mut self, it: &mut BindingRestElement<'a>) { + walk_binding_rest_element(self, it); + } + + #[inline] + fn visit_array_pattern(&mut self, it: &mut ArrayPattern<'a>) { + walk_array_pattern(self, it); + } + + #[inline] + fn visit_assignment_pattern(&mut self, it: &mut AssignmentPattern<'a>) { + walk_assignment_pattern(self, it); + } + + #[inline] + fn visit_ts_type_annotation(&mut self, it: &mut TSTypeAnnotation<'a>) { + walk_ts_type_annotation(self, it); + } + + #[inline] + fn visit_ts_type(&mut self, it: &mut TSType<'a>) { + walk_ts_type(self, it); + } + + #[inline] + fn visit_ts_any_keyword(&mut self, it: &mut TSAnyKeyword) { + walk_ts_any_keyword(self, it); + } + + #[inline] + fn visit_ts_big_int_keyword(&mut self, it: &mut TSBigIntKeyword) { + walk_ts_big_int_keyword(self, it); + } + + #[inline] + fn visit_ts_boolean_keyword(&mut self, it: &mut TSBooleanKeyword) { + walk_ts_boolean_keyword(self, it); + } + + #[inline] + fn visit_ts_intrinsic_keyword(&mut self, it: &mut TSIntrinsicKeyword) { + walk_ts_intrinsic_keyword(self, it); + } + + #[inline] + fn visit_ts_never_keyword(&mut self, it: &mut TSNeverKeyword) { + walk_ts_never_keyword(self, it); + } + + #[inline] + fn visit_ts_null_keyword(&mut self, it: &mut TSNullKeyword) { + walk_ts_null_keyword(self, it); + } + + #[inline] + fn visit_ts_number_keyword(&mut self, it: &mut TSNumberKeyword) { + walk_ts_number_keyword(self, it); + } + + #[inline] + fn visit_ts_object_keyword(&mut self, it: &mut TSObjectKeyword) { + walk_ts_object_keyword(self, it); + } + + #[inline] + fn visit_ts_string_keyword(&mut self, it: &mut TSStringKeyword) { + walk_ts_string_keyword(self, it); + } + + #[inline] + fn visit_ts_symbol_keyword(&mut self, it: &mut TSSymbolKeyword) { + walk_ts_symbol_keyword(self, it); + } + + #[inline] + fn visit_ts_undefined_keyword(&mut self, it: &mut TSUndefinedKeyword) { + walk_ts_undefined_keyword(self, it); + } + + #[inline] + fn visit_ts_unknown_keyword(&mut self, it: &mut TSUnknownKeyword) { + walk_ts_unknown_keyword(self, it); + } + + #[inline] + fn visit_ts_void_keyword(&mut self, it: &mut TSVoidKeyword) { + walk_ts_void_keyword(self, it); + } + + #[inline] + fn visit_ts_array_type(&mut self, it: &mut TSArrayType<'a>) { + walk_ts_array_type(self, it); + } + + #[inline] + fn visit_ts_conditional_type(&mut self, it: &mut TSConditionalType<'a>) { + walk_ts_conditional_type(self, it); + } + + #[inline] + fn visit_ts_constructor_type(&mut self, it: &mut TSConstructorType<'a>) { + walk_ts_constructor_type(self, it); + } + + #[inline] + fn visit_ts_type_parameter_declaration(&mut self, it: &mut TSTypeParameterDeclaration<'a>) { + walk_ts_type_parameter_declaration(self, it); + } + + #[inline] + fn visit_ts_type_parameters(&mut self, it: &mut Vec<'a, TSTypeParameter<'a>>) { + walk_ts_type_parameters(self, it); + } + + #[inline] + fn visit_ts_type_parameter(&mut self, it: &mut TSTypeParameter<'a>) { + walk_ts_type_parameter(self, it); + } + + #[inline] + fn visit_ts_function_type(&mut self, it: &mut TSFunctionType<'a>) { + walk_ts_function_type(self, it); + } + + #[inline] + fn visit_ts_this_parameter(&mut self, it: &mut TSThisParameter<'a>) { + walk_ts_this_parameter(self, it); + } + + #[inline] + fn visit_ts_import_type(&mut self, it: &mut TSImportType<'a>) { + walk_ts_import_type(self, it); + } + + #[inline] + fn visit_ts_type_name(&mut self, it: &mut TSTypeName<'a>) { + walk_ts_type_name(self, it); + } + + #[inline] + fn visit_ts_qualified_name(&mut self, it: &mut TSQualifiedName<'a>) { + walk_ts_qualified_name(self, it); + } + + #[inline] + fn visit_ts_import_attributes(&mut self, it: &mut TSImportAttributes<'a>) { + walk_ts_import_attributes(self, it); + } + + #[inline] + fn visit_ts_import_attribute_list(&mut self, it: &mut Vec<'a, TSImportAttribute<'a>>) { + walk_ts_import_attribute_list(self, it); + } + + #[inline] + fn visit_ts_import_attribute(&mut self, it: &mut TSImportAttribute<'a>) { + walk_ts_import_attribute(self, it); + } + + #[inline] + fn visit_ts_import_attribute_name(&mut self, it: &mut TSImportAttributeName<'a>) { + walk_ts_import_attribute_name(self, it); + } + + #[inline] + fn visit_ts_type_parameter_instantiation(&mut self, it: &mut TSTypeParameterInstantiation<'a>) { + walk_ts_type_parameter_instantiation(self, it); + } + + #[inline] + fn visit_ts_types(&mut self, it: &mut Vec<'a, TSType<'a>>) { + walk_ts_types(self, it); + } + + #[inline] + fn visit_ts_indexed_access_type(&mut self, it: &mut TSIndexedAccessType<'a>) { + walk_ts_indexed_access_type(self, it); + } + + #[inline] + fn visit_ts_infer_type(&mut self, it: &mut TSInferType<'a>) { + walk_ts_infer_type(self, it); + } + + #[inline] + fn visit_ts_intersection_type(&mut self, it: &mut TSIntersectionType<'a>) { + walk_ts_intersection_type(self, it); + } + + #[inline] + fn visit_ts_literal_type(&mut self, it: &mut TSLiteralType<'a>) { + walk_ts_literal_type(self, it); + } + + #[inline] + fn visit_ts_literal(&mut self, it: &mut TSLiteral<'a>) { + walk_ts_literal(self, it); + } + + #[inline] + fn visit_unary_expression(&mut self, it: &mut UnaryExpression<'a>) { + walk_unary_expression(self, it); + } + + #[inline] + fn visit_ts_mapped_type(&mut self, it: &mut TSMappedType<'a>) { + walk_ts_mapped_type(self, it); + } + + #[inline] + fn visit_ts_named_tuple_member(&mut self, it: &mut TSNamedTupleMember<'a>) { + walk_ts_named_tuple_member(self, it); + } + + #[inline] + fn visit_ts_tuple_element(&mut self, it: &mut TSTupleElement<'a>) { + walk_ts_tuple_element(self, it); + } + + #[inline] + fn visit_ts_optional_type(&mut self, it: &mut TSOptionalType<'a>) { + walk_ts_optional_type(self, it); + } + + #[inline] + fn visit_ts_rest_type(&mut self, it: &mut TSRestType<'a>) { + walk_ts_rest_type(self, it); + } + + #[inline] + fn visit_ts_template_literal_type(&mut self, it: &mut TSTemplateLiteralType<'a>) { + walk_ts_template_literal_type(self, it); + } + + #[inline] + fn visit_ts_this_type(&mut self, it: &mut TSThisType) { + walk_ts_this_type(self, it); + } + + #[inline] + fn visit_ts_tuple_type(&mut self, it: &mut TSTupleType<'a>) { + walk_ts_tuple_type(self, it); + } + + #[inline] + fn visit_ts_tuple_elements(&mut self, it: &mut Vec<'a, TSTupleElement<'a>>) { + walk_ts_tuple_elements(self, it); + } + + #[inline] + fn visit_ts_type_literal(&mut self, it: &mut TSTypeLiteral<'a>) { + walk_ts_type_literal(self, it); + } + + #[inline] + fn visit_ts_signatures(&mut self, it: &mut Vec<'a, TSSignature<'a>>) { + walk_ts_signatures(self, it); + } + + #[inline] + fn visit_ts_signature(&mut self, it: &mut TSSignature<'a>) { + walk_ts_signature(self, it); + } + + #[inline] + fn visit_ts_index_signature(&mut self, it: &mut TSIndexSignature<'a>) { + walk_ts_index_signature(self, it); + } + + #[inline] + fn visit_ts_index_signature_names(&mut self, it: &mut Vec<'a, TSIndexSignatureName<'a>>) { + walk_ts_index_signature_names(self, it); + } + + #[inline] + fn visit_ts_index_signature_name(&mut self, it: &mut TSIndexSignatureName<'a>) { + walk_ts_index_signature_name(self, it); + } + + #[inline] + fn visit_ts_property_signature(&mut self, it: &mut TSPropertySignature<'a>) { + walk_ts_property_signature(self, it); + } + + #[inline] + fn visit_ts_call_signature_declaration(&mut self, it: &mut TSCallSignatureDeclaration<'a>) { + walk_ts_call_signature_declaration(self, it); + } + + #[inline] + fn visit_ts_construct_signature_declaration( + &mut self, + it: &mut TSConstructSignatureDeclaration<'a>, + ) { + walk_ts_construct_signature_declaration(self, it); + } + + #[inline] + fn visit_ts_method_signature(&mut self, it: &mut TSMethodSignature<'a>) { + walk_ts_method_signature(self, it); + } + + #[inline] + fn visit_ts_type_operator(&mut self, it: &mut TSTypeOperator<'a>) { + walk_ts_type_operator(self, it); + } + + #[inline] + fn visit_ts_type_predicate(&mut self, it: &mut TSTypePredicate<'a>) { + walk_ts_type_predicate(self, it); + } + + #[inline] + fn visit_ts_type_predicate_name(&mut self, it: &mut TSTypePredicateName<'a>) { + walk_ts_type_predicate_name(self, it); + } + + #[inline] + fn visit_ts_type_query(&mut self, it: &mut TSTypeQuery<'a>) { + walk_ts_type_query(self, it); + } + + #[inline] + fn visit_ts_type_query_expr_name(&mut self, it: &mut TSTypeQueryExprName<'a>) { + walk_ts_type_query_expr_name(self, it); + } + + #[inline] + fn visit_ts_type_reference(&mut self, it: &mut TSTypeReference<'a>) { + walk_ts_type_reference(self, it); + } + + #[inline] + fn visit_ts_union_type(&mut self, it: &mut TSUnionType<'a>) { + walk_ts_union_type(self, it); + } + + #[inline] + fn visit_ts_parenthesized_type(&mut self, it: &mut TSParenthesizedType<'a>) { + walk_ts_parenthesized_type(self, it); + } + + #[inline] + fn visit_js_doc_nullable_type(&mut self, it: &mut JSDocNullableType<'a>) { + walk_js_doc_nullable_type(self, it); + } + + #[inline] + fn visit_js_doc_non_nullable_type(&mut self, it: &mut JSDocNonNullableType<'a>) { + walk_js_doc_non_nullable_type(self, it); + } + + #[inline] + fn visit_js_doc_unknown_type(&mut self, it: &mut JSDocUnknownType) { + walk_js_doc_unknown_type(self, it); + } + + #[inline] + fn visit_decorators(&mut self, it: &mut Vec<'a, Decorator<'a>>) { + walk_decorators(self, it); + } + + #[inline] + fn visit_decorator(&mut self, it: &mut Decorator<'a>) { + walk_decorator(self, it); + } + + #[inline] + fn visit_function_body(&mut self, it: &mut FunctionBody<'a>) { + walk_function_body(self, it); + } + + #[inline] + fn visit_assignment_expression(&mut self, it: &mut AssignmentExpression<'a>) { + walk_assignment_expression(self, it); + } + + #[inline] + fn visit_assignment_target(&mut self, it: &mut AssignmentTarget<'a>) { + walk_assignment_target(self, it); + } + + #[inline] + fn visit_simple_assignment_target(&mut self, it: &mut SimpleAssignmentTarget<'a>) { + walk_simple_assignment_target(self, it); + } + + #[inline] + fn visit_ts_as_expression(&mut self, it: &mut TSAsExpression<'a>) { + walk_ts_as_expression(self, it); + } + + #[inline] + fn visit_ts_satisfies_expression(&mut self, it: &mut TSSatisfiesExpression<'a>) { + walk_ts_satisfies_expression(self, it); + } + + #[inline] + fn visit_ts_non_null_expression(&mut self, it: &mut TSNonNullExpression<'a>) { + walk_ts_non_null_expression(self, it); + } + + #[inline] + fn visit_ts_type_assertion(&mut self, it: &mut TSTypeAssertion<'a>) { + walk_ts_type_assertion(self, it); + } + + #[inline] + fn visit_ts_instantiation_expression(&mut self, it: &mut TSInstantiationExpression<'a>) { + walk_ts_instantiation_expression(self, it); + } + + #[inline] + fn visit_member_expression(&mut self, it: &mut MemberExpression<'a>) { + walk_member_expression(self, it); + } + + #[inline] + fn visit_computed_member_expression(&mut self, it: &mut ComputedMemberExpression<'a>) { + walk_computed_member_expression(self, it); + } + + #[inline] + fn visit_static_member_expression(&mut self, it: &mut StaticMemberExpression<'a>) { + walk_static_member_expression(self, it); + } + + #[inline] + fn visit_private_field_expression(&mut self, it: &mut PrivateFieldExpression<'a>) { + walk_private_field_expression(self, it); + } + + #[inline] + fn visit_assignment_target_pattern(&mut self, it: &mut AssignmentTargetPattern<'a>) { + walk_assignment_target_pattern(self, it); + } + + #[inline] + fn visit_array_assignment_target(&mut self, it: &mut ArrayAssignmentTarget<'a>) { + walk_array_assignment_target(self, it); + } + + #[inline] + fn visit_assignment_target_maybe_default(&mut self, it: &mut AssignmentTargetMaybeDefault<'a>) { + walk_assignment_target_maybe_default(self, it); + } + + #[inline] + fn visit_assignment_target_with_default(&mut self, it: &mut AssignmentTargetWithDefault<'a>) { + walk_assignment_target_with_default(self, it); + } + + #[inline] + fn visit_assignment_target_rest(&mut self, it: &mut AssignmentTargetRest<'a>) { + walk_assignment_target_rest(self, it); + } + + #[inline] + fn visit_object_assignment_target(&mut self, it: &mut ObjectAssignmentTarget<'a>) { + walk_object_assignment_target(self, it); + } + + #[inline] + fn visit_assignment_target_properties( + &mut self, + it: &mut Vec<'a, AssignmentTargetProperty<'a>>, + ) { + walk_assignment_target_properties(self, it); + } + + #[inline] + fn visit_assignment_target_property(&mut self, it: &mut AssignmentTargetProperty<'a>) { + walk_assignment_target_property(self, it); + } + + #[inline] + fn visit_assignment_target_property_identifier( + &mut self, + it: &mut AssignmentTargetPropertyIdentifier<'a>, + ) { + walk_assignment_target_property_identifier(self, it); + } + + #[inline] + fn visit_assignment_target_property_property( + &mut self, + it: &mut AssignmentTargetPropertyProperty<'a>, + ) { + walk_assignment_target_property_property(self, it); + } + + #[inline] + fn visit_await_expression(&mut self, it: &mut AwaitExpression<'a>) { + walk_await_expression(self, it); + } + + #[inline] + fn visit_binary_expression(&mut self, it: &mut BinaryExpression<'a>) { + walk_binary_expression(self, it); + } + + #[inline] + fn visit_call_expression(&mut self, it: &mut CallExpression<'a>) { + walk_call_expression(self, it); + } + + #[inline] + fn visit_arguments(&mut self, it: &mut Vec<'a, Argument<'a>>) { + walk_arguments(self, it); + } + + #[inline] + fn visit_argument(&mut self, it: &mut Argument<'a>) { + walk_argument(self, it); + } + + #[inline] + fn visit_chain_expression(&mut self, it: &mut ChainExpression<'a>) { + walk_chain_expression(self, it); + } + + #[inline] + fn visit_chain_element(&mut self, it: &mut ChainElement<'a>) { + walk_chain_element(self, it); + } + + #[inline] + fn visit_class(&mut self, it: &mut Class<'a>) { + walk_class(self, it); + } + + #[inline] + fn visit_class_heritage(&mut self, it: &mut Expression<'a>) { + walk_class_heritage(self, it); + } + + #[inline] + fn visit_conditional_expression(&mut self, it: &mut ConditionalExpression<'a>) { + walk_conditional_expression(self, it); + } + + #[inline] + fn visit_function(&mut self, it: &mut Function<'a>, flags: Option) { + walk_function(self, it, flags); + } + + #[inline] + fn visit_import_expression(&mut self, it: &mut ImportExpression<'a>) { + walk_import_expression(self, it); + } + + #[inline] + fn visit_logical_expression(&mut self, it: &mut LogicalExpression<'a>) { + walk_logical_expression(self, it); + } + + #[inline] + fn visit_new_expression(&mut self, it: &mut NewExpression<'a>) { + walk_new_expression(self, it); + } + + #[inline] + fn visit_object_expression(&mut self, it: &mut ObjectExpression<'a>) { + walk_object_expression(self, it); + } + + #[inline] + fn visit_object_property_kinds(&mut self, it: &mut Vec<'a, ObjectPropertyKind<'a>>) { + walk_object_property_kinds(self, it); + } + + #[inline] + fn visit_object_property_kind(&mut self, it: &mut ObjectPropertyKind<'a>) { + walk_object_property_kind(self, it); + } + + #[inline] + fn visit_object_property(&mut self, it: &mut ObjectProperty<'a>) { + walk_object_property(self, it); + } + + #[inline] + fn visit_parenthesized_expression(&mut self, it: &mut ParenthesizedExpression<'a>) { + walk_parenthesized_expression(self, it); + } + + #[inline] + fn visit_sequence_expression(&mut self, it: &mut SequenceExpression<'a>) { + walk_sequence_expression(self, it); + } + + #[inline] + fn visit_tagged_template_expression(&mut self, it: &mut TaggedTemplateExpression<'a>) { + walk_tagged_template_expression(self, it); + } + + #[inline] + fn visit_this_expression(&mut self, it: &mut ThisExpression) { + walk_this_expression(self, it); + } + + #[inline] + fn visit_update_expression(&mut self, it: &mut UpdateExpression<'a>) { + walk_update_expression(self, it); + } + + #[inline] + fn visit_yield_expression(&mut self, it: &mut YieldExpression<'a>) { + walk_yield_expression(self, it); + } + + #[inline] + fn visit_private_in_expression(&mut self, it: &mut PrivateInExpression<'a>) { + walk_private_in_expression(self, it); + } + + #[inline] + fn visit_jsx_element(&mut self, it: &mut JSXElement<'a>) { + walk_jsx_element(self, it); + } + + #[inline] + fn visit_jsx_opening_element(&mut self, it: &mut JSXOpeningElement<'a>) { + walk_jsx_opening_element(self, it); + } + + #[inline] + fn visit_jsx_element_name(&mut self, it: &mut JSXElementName<'a>) { + walk_jsx_element_name(self, it); + } + + #[inline] + fn visit_jsx_identifier(&mut self, it: &mut JSXIdentifier<'a>) { + walk_jsx_identifier(self, it); + } + + #[inline] + fn visit_jsx_namespaced_name(&mut self, it: &mut JSXNamespacedName<'a>) { + walk_jsx_namespaced_name(self, it); + } + + #[inline] + fn visit_jsx_member_expression(&mut self, it: &mut JSXMemberExpression<'a>) { + walk_jsx_member_expression(self, it); + } + + #[inline] + fn visit_jsx_member_expression_object(&mut self, it: &mut JSXMemberExpressionObject<'a>) { + walk_jsx_member_expression_object(self, it); + } + + #[inline] + fn visit_jsx_attribute_items(&mut self, it: &mut Vec<'a, JSXAttributeItem<'a>>) { + walk_jsx_attribute_items(self, it); + } + + #[inline] + fn visit_jsx_attribute_item(&mut self, it: &mut JSXAttributeItem<'a>) { + walk_jsx_attribute_item(self, it); + } + + #[inline] + fn visit_jsx_attribute(&mut self, it: &mut JSXAttribute<'a>) { + walk_jsx_attribute(self, it); + } + + #[inline] + fn visit_jsx_attribute_name(&mut self, it: &mut JSXAttributeName<'a>) { + walk_jsx_attribute_name(self, it); + } + + #[inline] + fn visit_jsx_attribute_value(&mut self, it: &mut JSXAttributeValue<'a>) { + walk_jsx_attribute_value(self, it); + } + + #[inline] + fn visit_jsx_expression_container(&mut self, it: &mut JSXExpressionContainer<'a>) { + walk_jsx_expression_container(self, it); + } + + #[inline] + fn visit_jsx_expression(&mut self, it: &mut JSXExpression<'a>) { + walk_jsx_expression(self, it); + } + + #[inline] + fn visit_jsx_empty_expression(&mut self, it: &mut JSXEmptyExpression) { + walk_jsx_empty_expression(self, it); + } + + #[inline] + fn visit_jsx_fragment(&mut self, it: &mut JSXFragment<'a>) { + walk_jsx_fragment(self, it); + } + + #[inline] + fn visit_jsx_children(&mut self, it: &mut Vec<'a, JSXChild<'a>>) { + walk_jsx_children(self, it); + } + + #[inline] + fn visit_jsx_child(&mut self, it: &mut JSXChild<'a>) { + walk_jsx_child(self, it); + } + + #[inline] + fn visit_jsx_text(&mut self, it: &mut JSXText<'a>) { + walk_jsx_text(self, it); + } + + #[inline] + fn visit_jsx_spread_child(&mut self, it: &mut JSXSpreadChild<'a>) { + walk_jsx_spread_child(self, it); + } + + #[inline] + fn visit_jsx_spread_attribute(&mut self, it: &mut JSXSpreadAttribute<'a>) { + walk_jsx_spread_attribute(self, it); + } + + #[inline] + fn visit_jsx_closing_element(&mut self, it: &mut JSXClosingElement<'a>) { + walk_jsx_closing_element(self, it); + } + + #[inline] + fn visit_class_body(&mut self, it: &mut ClassBody<'a>) { + walk_class_body(self, it); + } + + #[inline] + fn visit_class_elements(&mut self, it: &mut Vec<'a, ClassElement<'a>>) { + walk_class_elements(self, it); + } + + #[inline] + fn visit_class_element(&mut self, it: &mut ClassElement<'a>) { + walk_class_element(self, it); + } + + #[inline] + fn visit_static_block(&mut self, it: &mut StaticBlock<'a>) { + walk_static_block(self, it); + } + + #[inline] + fn visit_method_definition(&mut self, it: &mut MethodDefinition<'a>) { + walk_method_definition(self, it); + } + + #[inline] + fn visit_property_definition(&mut self, it: &mut PropertyDefinition<'a>) { + walk_property_definition(self, it); + } + + #[inline] + fn visit_accessor_property(&mut self, it: &mut AccessorProperty<'a>) { + walk_accessor_property(self, it); + } + + #[inline] + fn visit_ts_class_implementses(&mut self, it: &mut Vec<'a, TSClassImplements<'a>>) { + walk_ts_class_implementses(self, it); + } + + #[inline] + fn visit_ts_class_implements(&mut self, it: &mut TSClassImplements<'a>) { + walk_ts_class_implements(self, it); + } + + #[inline] + fn visit_empty_statement(&mut self, it: &mut EmptyStatement) { + walk_empty_statement(self, it); + } + + #[inline] + fn visit_expression_statement(&mut self, it: &mut ExpressionStatement<'a>) { + walk_expression_statement(self, it); + } + + #[inline] + fn visit_for_in_statement(&mut self, it: &mut ForInStatement<'a>) { + walk_for_in_statement(self, it); + } + + #[inline] + fn visit_for_statement_left(&mut self, it: &mut ForStatementLeft<'a>) { + walk_for_statement_left(self, it); + } + + #[inline] + fn visit_variable_declaration(&mut self, it: &mut VariableDeclaration<'a>) { + walk_variable_declaration(self, it); + } + + #[inline] + fn visit_variable_declarators(&mut self, it: &mut Vec<'a, VariableDeclarator<'a>>) { + walk_variable_declarators(self, it); + } + + #[inline] + fn visit_variable_declarator(&mut self, it: &mut VariableDeclarator<'a>) { + walk_variable_declarator(self, it); + } + + #[inline] + fn visit_using_declaration(&mut self, it: &mut UsingDeclaration<'a>) { + walk_using_declaration(self, it); + } + + #[inline] + fn visit_for_of_statement(&mut self, it: &mut ForOfStatement<'a>) { + walk_for_of_statement(self, it); + } + + #[inline] + fn visit_for_statement(&mut self, it: &mut ForStatement<'a>) { + walk_for_statement(self, it); + } + + #[inline] + fn visit_for_statement_init(&mut self, it: &mut ForStatementInit<'a>) { + walk_for_statement_init(self, it); + } + + #[inline] + fn visit_if_statement(&mut self, it: &mut IfStatement<'a>) { + walk_if_statement(self, it); + } + + #[inline] + fn visit_labeled_statement(&mut self, it: &mut LabeledStatement<'a>) { + walk_labeled_statement(self, it); + } + + #[inline] + fn visit_return_statement(&mut self, it: &mut ReturnStatement<'a>) { + walk_return_statement(self, it); + } + + #[inline] + fn visit_switch_statement(&mut self, it: &mut SwitchStatement<'a>) { + walk_switch_statement(self, it); + } + + #[inline] + fn visit_switch_cases(&mut self, it: &mut Vec<'a, SwitchCase<'a>>) { + walk_switch_cases(self, it); + } + + #[inline] + fn visit_switch_case(&mut self, it: &mut SwitchCase<'a>) { + walk_switch_case(self, it); + } + + #[inline] + fn visit_throw_statement(&mut self, it: &mut ThrowStatement<'a>) { + walk_throw_statement(self, it); + } + + #[inline] + fn visit_try_statement(&mut self, it: &mut TryStatement<'a>) { + walk_try_statement(self, it); + } + + #[inline] + fn visit_catch_clause(&mut self, it: &mut CatchClause<'a>) { + walk_catch_clause(self, it); + } + + #[inline] + fn visit_catch_parameter(&mut self, it: &mut CatchParameter<'a>) { + walk_catch_parameter(self, it); + } + + #[inline] + fn visit_finally_clause(&mut self, it: &mut BlockStatement<'a>) { + walk_finally_clause(self, it); + } + + #[inline] + fn visit_while_statement(&mut self, it: &mut WhileStatement<'a>) { + walk_while_statement(self, it); + } + + #[inline] + fn visit_with_statement(&mut self, it: &mut WithStatement<'a>) { + walk_with_statement(self, it); + } + + #[inline] + fn visit_declaration(&mut self, it: &mut Declaration<'a>) { + walk_declaration(self, it); + } + + #[inline] + fn visit_ts_type_alias_declaration(&mut self, it: &mut TSTypeAliasDeclaration<'a>) { + walk_ts_type_alias_declaration(self, it); + } + + #[inline] + fn visit_ts_interface_declaration(&mut self, it: &mut TSInterfaceDeclaration<'a>) { + walk_ts_interface_declaration(self, it); + } + + #[inline] + fn visit_ts_interface_heritages(&mut self, it: &mut Vec<'a, TSInterfaceHeritage<'a>>) { + walk_ts_interface_heritages(self, it); + } + + #[inline] + fn visit_ts_interface_heritage(&mut self, it: &mut TSInterfaceHeritage<'a>) { + walk_ts_interface_heritage(self, it); + } + + #[inline] + fn visit_ts_interface_body(&mut self, it: &mut TSInterfaceBody<'a>) { + walk_ts_interface_body(self, it); + } + + #[inline] + fn visit_ts_enum_declaration(&mut self, it: &mut TSEnumDeclaration<'a>) { + walk_ts_enum_declaration(self, it); + } + + #[inline] + fn visit_ts_enum_members(&mut self, it: &mut Vec<'a, TSEnumMember<'a>>) { + walk_ts_enum_members(self, it); + } + + #[inline] + fn visit_ts_enum_member(&mut self, it: &mut TSEnumMember<'a>) { + walk_ts_enum_member(self, it); + } + + #[inline] + fn visit_ts_enum_member_name(&mut self, it: &mut TSEnumMemberName<'a>) { + walk_ts_enum_member_name(self, it); + } + + #[inline] + fn visit_ts_module_declaration(&mut self, it: &mut TSModuleDeclaration<'a>) { + walk_ts_module_declaration(self, it); + } + + #[inline] + fn visit_ts_module_declaration_name(&mut self, it: &mut TSModuleDeclarationName<'a>) { + walk_ts_module_declaration_name(self, it); + } + + #[inline] + fn visit_ts_module_declaration_body(&mut self, it: &mut TSModuleDeclarationBody<'a>) { + walk_ts_module_declaration_body(self, it); + } + + #[inline] + fn visit_ts_module_block(&mut self, it: &mut TSModuleBlock<'a>) { + walk_ts_module_block(self, it); + } + + #[inline] + fn visit_ts_import_equals_declaration(&mut self, it: &mut TSImportEqualsDeclaration<'a>) { + walk_ts_import_equals_declaration(self, it); + } + + #[inline] + fn visit_ts_module_reference(&mut self, it: &mut TSModuleReference<'a>) { + walk_ts_module_reference(self, it); + } + + #[inline] + fn visit_ts_external_module_reference(&mut self, it: &mut TSExternalModuleReference<'a>) { + walk_ts_external_module_reference(self, it); + } + + #[inline] + fn visit_module_declaration(&mut self, it: &mut ModuleDeclaration<'a>) { + walk_module_declaration(self, it); + } + + #[inline] + fn visit_import_declaration(&mut self, it: &mut ImportDeclaration<'a>) { + walk_import_declaration(self, it); + } + + #[inline] + fn visit_import_declaration_specifiers( + &mut self, + it: &mut Vec<'a, ImportDeclarationSpecifier<'a>>, + ) { + walk_import_declaration_specifiers(self, it); + } + + #[inline] + fn visit_import_declaration_specifier(&mut self, it: &mut ImportDeclarationSpecifier<'a>) { + walk_import_declaration_specifier(self, it); + } + + #[inline] + fn visit_import_specifier(&mut self, it: &mut ImportSpecifier<'a>) { + walk_import_specifier(self, it); + } + + #[inline] + fn visit_module_export_name(&mut self, it: &mut ModuleExportName<'a>) { + walk_module_export_name(self, it); + } + + #[inline] + fn visit_import_default_specifier(&mut self, it: &mut ImportDefaultSpecifier<'a>) { + walk_import_default_specifier(self, it); + } + + #[inline] + fn visit_import_namespace_specifier(&mut self, it: &mut ImportNamespaceSpecifier<'a>) { + walk_import_namespace_specifier(self, it); + } + + #[inline] + fn visit_with_clause(&mut self, it: &mut WithClause<'a>) { + walk_with_clause(self, it); + } + + #[inline] + fn visit_import_attributes(&mut self, it: &mut Vec<'a, ImportAttribute<'a>>) { + walk_import_attributes(self, it); + } + + #[inline] + fn visit_import_attribute(&mut self, it: &mut ImportAttribute<'a>) { + walk_import_attribute(self, it); + } + + #[inline] + fn visit_import_attribute_key(&mut self, it: &mut ImportAttributeKey<'a>) { + walk_import_attribute_key(self, it); + } + + #[inline] + fn visit_export_all_declaration(&mut self, it: &mut ExportAllDeclaration<'a>) { + walk_export_all_declaration(self, it); + } + + #[inline] + fn visit_export_default_declaration(&mut self, it: &mut ExportDefaultDeclaration<'a>) { + walk_export_default_declaration(self, it); + } + + #[inline] + fn visit_export_default_declaration_kind(&mut self, it: &mut ExportDefaultDeclarationKind<'a>) { + walk_export_default_declaration_kind(self, it); + } + + #[inline] + fn visit_export_named_declaration(&mut self, it: &mut ExportNamedDeclaration<'a>) { + walk_export_named_declaration(self, it); + } + + #[inline] + fn visit_export_specifiers(&mut self, it: &mut Vec<'a, ExportSpecifier<'a>>) { + walk_export_specifiers(self, it); + } + + #[inline] + fn visit_export_specifier(&mut self, it: &mut ExportSpecifier<'a>) { + walk_export_specifier(self, it); + } + + #[inline] + fn visit_ts_export_assignment(&mut self, it: &mut TSExportAssignment<'a>) { + walk_ts_export_assignment(self, it); + } + + #[inline] + fn visit_ts_namespace_export_declaration(&mut self, it: &mut TSNamespaceExportDeclaration<'a>) { + walk_ts_namespace_export_declaration(self, it); + } +} + +pub mod walk_mut { + use super::*; + + #[inline] + pub fn walk_program<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Program<'a>) { + visitor.enter_scope({ + let mut flags = ScopeFlags::Top; + if it.source_type.is_strict() || it.directives.iter().any(Directive::is_use_strict) { + flags |= ScopeFlags::StrictMode; + } + flags + }); + let kind = AstType::Program; + visitor.enter_node(kind); + visitor.visit_directives(&mut it.directives); + if let Some(hashbang) = &mut it.hashbang { + visitor.visit_hashbang(hashbang); + } + visitor.visit_statements(&mut it.body); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_directives<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Vec<'a, Directive<'a>>) { + for el in it.iter_mut() { + visitor.visit_directive(el); + } + } + + #[inline] + pub fn walk_directive<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Directive<'a>) { + let kind = AstType::Directive; + visitor.enter_node(kind); + visitor.visit_string_literal(&mut it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_string_literal<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut StringLiteral<'a>) { + let kind = AstType::StringLiteral; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_hashbang<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Hashbang<'a>) { + let kind = AstType::Hashbang; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_statements<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Vec<'a, Statement<'a>>) { + for el in it.iter_mut() { + visitor.visit_statement(el); + } + } + + pub fn walk_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Statement<'a>) { + match it { + Statement::BlockStatement(it) => visitor.visit_block_statement(it), + Statement::BreakStatement(it) => visitor.visit_break_statement(it), + Statement::ContinueStatement(it) => visitor.visit_continue_statement(it), + Statement::DebuggerStatement(it) => visitor.visit_debugger_statement(it), + Statement::DoWhileStatement(it) => visitor.visit_do_while_statement(it), + Statement::EmptyStatement(it) => visitor.visit_empty_statement(it), + Statement::ExpressionStatement(it) => visitor.visit_expression_statement(it), + Statement::ForInStatement(it) => visitor.visit_for_in_statement(it), + Statement::ForOfStatement(it) => visitor.visit_for_of_statement(it), + Statement::ForStatement(it) => visitor.visit_for_statement(it), + Statement::IfStatement(it) => visitor.visit_if_statement(it), + Statement::LabeledStatement(it) => visitor.visit_labeled_statement(it), + Statement::ReturnStatement(it) => visitor.visit_return_statement(it), + Statement::SwitchStatement(it) => visitor.visit_switch_statement(it), + Statement::ThrowStatement(it) => visitor.visit_throw_statement(it), + Statement::TryStatement(it) => visitor.visit_try_statement(it), + Statement::WhileStatement(it) => visitor.visit_while_statement(it), + Statement::WithStatement(it) => visitor.visit_with_statement(it), + match_declaration!(Statement) => visitor.visit_declaration(it.to_declaration_mut()), + match_module_declaration!(Statement) => { + visitor.visit_module_declaration(it.to_module_declaration_mut()) + } + } + } + + #[inline] + pub fn walk_block_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut BlockStatement<'a>) { + visitor.enter_scope(ScopeFlags::empty()); + let kind = AstType::BlockStatement; + visitor.enter_node(kind); + visitor.visit_statements(&mut it.body); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_break_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut BreakStatement<'a>) { + let kind = AstType::BreakStatement; + visitor.enter_node(kind); + if let Some(label) = &mut it.label { + visitor.visit_label_identifier(label); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_label_identifier<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut LabelIdentifier<'a>, + ) { + let kind = AstType::LabelIdentifier; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_continue_statement<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ContinueStatement<'a>, + ) { + let kind = AstType::ContinueStatement; + visitor.enter_node(kind); + if let Some(label) = &mut it.label { + visitor.visit_label_identifier(label); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_debugger_statement<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut DebuggerStatement, + ) { + let kind = AstType::DebuggerStatement; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_do_while_statement<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut DoWhileStatement<'a>, + ) { + let kind = AstType::DoWhileStatement; + visitor.enter_node(kind); + visitor.visit_statement(&mut it.body); + visitor.visit_expression(&mut it.test); + visitor.leave_node(kind); + } + + pub fn walk_expression<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Expression<'a>) { + match it { + Expression::BooleanLiteral(it) => visitor.visit_boolean_literal(it), + Expression::NullLiteral(it) => visitor.visit_null_literal(it), + Expression::NumericLiteral(it) => visitor.visit_numeric_literal(it), + Expression::BigIntLiteral(it) => visitor.visit_big_int_literal(it), + Expression::RegExpLiteral(it) => visitor.visit_reg_exp_literal(it), + Expression::StringLiteral(it) => visitor.visit_string_literal(it), + Expression::TemplateLiteral(it) => visitor.visit_template_literal(it), + Expression::Identifier(it) => visitor.visit_identifier_reference(it), + Expression::MetaProperty(it) => visitor.visit_meta_property(it), + Expression::Super(it) => visitor.visit_super(it), + Expression::ArrayExpression(it) => visitor.visit_array_expression(it), + Expression::ArrowFunctionExpression(it) => visitor.visit_arrow_function_expression(it), + Expression::AssignmentExpression(it) => visitor.visit_assignment_expression(it), + Expression::AwaitExpression(it) => visitor.visit_await_expression(it), + Expression::BinaryExpression(it) => visitor.visit_binary_expression(it), + Expression::CallExpression(it) => visitor.visit_call_expression(it), + Expression::ChainExpression(it) => visitor.visit_chain_expression(it), + Expression::ClassExpression(it) => visitor.visit_class(it), + Expression::ConditionalExpression(it) => visitor.visit_conditional_expression(it), + Expression::FunctionExpression(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + Expression::ImportExpression(it) => visitor.visit_import_expression(it), + Expression::LogicalExpression(it) => visitor.visit_logical_expression(it), + Expression::NewExpression(it) => visitor.visit_new_expression(it), + Expression::ObjectExpression(it) => visitor.visit_object_expression(it), + Expression::ParenthesizedExpression(it) => visitor.visit_parenthesized_expression(it), + Expression::SequenceExpression(it) => visitor.visit_sequence_expression(it), + Expression::TaggedTemplateExpression(it) => { + visitor.visit_tagged_template_expression(it) + } + Expression::ThisExpression(it) => visitor.visit_this_expression(it), + Expression::UnaryExpression(it) => visitor.visit_unary_expression(it), + Expression::UpdateExpression(it) => visitor.visit_update_expression(it), + Expression::YieldExpression(it) => visitor.visit_yield_expression(it), + Expression::PrivateInExpression(it) => visitor.visit_private_in_expression(it), + Expression::JSXElement(it) => visitor.visit_jsx_element(it), + Expression::JSXFragment(it) => visitor.visit_jsx_fragment(it), + Expression::TSAsExpression(it) => visitor.visit_ts_as_expression(it), + Expression::TSSatisfiesExpression(it) => visitor.visit_ts_satisfies_expression(it), + Expression::TSTypeAssertion(it) => visitor.visit_ts_type_assertion(it), + Expression::TSNonNullExpression(it) => visitor.visit_ts_non_null_expression(it), + Expression::TSInstantiationExpression(it) => { + visitor.visit_ts_instantiation_expression(it) + } + match_member_expression!(Expression) => { + visitor.visit_member_expression(it.to_member_expression_mut()) + } + } + } + + #[inline] + pub fn walk_boolean_literal<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut BooleanLiteral) { + let kind = AstType::BooleanLiteral; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_null_literal<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut NullLiteral) { + let kind = AstType::NullLiteral; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_numeric_literal<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut NumericLiteral<'a>) { + let kind = AstType::NumericLiteral; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_big_int_literal<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut BigIntLiteral<'a>) { + let kind = AstType::BigIntLiteral; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_reg_exp_literal<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut RegExpLiteral<'a>) { + let kind = AstType::RegExpLiteral; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_template_literal<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TemplateLiteral<'a>, + ) { + let kind = AstType::TemplateLiteral; + visitor.enter_node(kind); + visitor.visit_template_elements(&mut it.quasis); + visitor.visit_expressions(&mut it.expressions); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_template_elements<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, TemplateElement<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_template_element(el); + } + } + + #[inline] + pub fn walk_template_element<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TemplateElement<'a>, + ) { + // NOTE: AstType doesn't exists! + } + + #[inline] + pub fn walk_expressions<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, Expression<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_expression(el); + } + } + + #[inline] + pub fn walk_identifier_reference<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut IdentifierReference<'a>, + ) { + let kind = AstType::IdentifierReference; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_meta_property<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut MetaProperty<'a>) { + let kind = AstType::MetaProperty; + visitor.enter_node(kind); + visitor.visit_identifier_name(&mut it.meta); + visitor.visit_identifier_name(&mut it.property); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_identifier_name<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut IdentifierName<'a>) { + let kind = AstType::IdentifierName; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_super<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Super) { + let kind = AstType::Super; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_array_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ArrayExpression<'a>, + ) { + let kind = AstType::ArrayExpression; + visitor.enter_node(kind); + visitor.visit_array_expression_elements(&mut it.elements); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_array_expression_elements<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, ArrayExpressionElement<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_array_expression_element(el); + } + } + + #[inline] + pub fn walk_array_expression_element<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ArrayExpressionElement<'a>, + ) { + let kind = AstType::ArrayExpressionElement; + visitor.enter_node(kind); + match it { + ArrayExpressionElement::SpreadElement(it) => visitor.visit_spread_element(it), + ArrayExpressionElement::Elision(it) => visitor.visit_elision(it), + match_expression!(ArrayExpressionElement) => { + visitor.visit_expression_array_element(it.to_expression_mut()) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_spread_element<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut SpreadElement<'a>) { + let kind = AstType::SpreadElement; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_elision<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Elision) { + let kind = AstType::Elision; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + pub fn walk_expression_array_element<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Expression<'a>, + ) { + let kind = AstType::ExpressionArrayElement; + visitor.enter_node(kind); + match it { + Expression::BooleanLiteral(it) => visitor.visit_boolean_literal(it), + Expression::NullLiteral(it) => visitor.visit_null_literal(it), + Expression::NumericLiteral(it) => visitor.visit_numeric_literal(it), + Expression::BigIntLiteral(it) => visitor.visit_big_int_literal(it), + Expression::RegExpLiteral(it) => visitor.visit_reg_exp_literal(it), + Expression::StringLiteral(it) => visitor.visit_string_literal(it), + Expression::TemplateLiteral(it) => visitor.visit_template_literal(it), + Expression::Identifier(it) => visitor.visit_identifier_reference(it), + Expression::MetaProperty(it) => visitor.visit_meta_property(it), + Expression::Super(it) => visitor.visit_super(it), + Expression::ArrayExpression(it) => visitor.visit_array_expression(it), + Expression::ArrowFunctionExpression(it) => visitor.visit_arrow_function_expression(it), + Expression::AssignmentExpression(it) => visitor.visit_assignment_expression(it), + Expression::AwaitExpression(it) => visitor.visit_await_expression(it), + Expression::BinaryExpression(it) => visitor.visit_binary_expression(it), + Expression::CallExpression(it) => visitor.visit_call_expression(it), + Expression::ChainExpression(it) => visitor.visit_chain_expression(it), + Expression::ClassExpression(it) => visitor.visit_class(it), + Expression::ConditionalExpression(it) => visitor.visit_conditional_expression(it), + Expression::FunctionExpression(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + Expression::ImportExpression(it) => visitor.visit_import_expression(it), + Expression::LogicalExpression(it) => visitor.visit_logical_expression(it), + Expression::NewExpression(it) => visitor.visit_new_expression(it), + Expression::ObjectExpression(it) => visitor.visit_object_expression(it), + Expression::ParenthesizedExpression(it) => visitor.visit_parenthesized_expression(it), + Expression::SequenceExpression(it) => visitor.visit_sequence_expression(it), + Expression::TaggedTemplateExpression(it) => { + visitor.visit_tagged_template_expression(it) + } + Expression::ThisExpression(it) => visitor.visit_this_expression(it), + Expression::UnaryExpression(it) => visitor.visit_unary_expression(it), + Expression::UpdateExpression(it) => visitor.visit_update_expression(it), + Expression::YieldExpression(it) => visitor.visit_yield_expression(it), + Expression::PrivateInExpression(it) => visitor.visit_private_in_expression(it), + Expression::JSXElement(it) => visitor.visit_jsx_element(it), + Expression::JSXFragment(it) => visitor.visit_jsx_fragment(it), + Expression::TSAsExpression(it) => visitor.visit_ts_as_expression(it), + Expression::TSSatisfiesExpression(it) => visitor.visit_ts_satisfies_expression(it), + Expression::TSTypeAssertion(it) => visitor.visit_ts_type_assertion(it), + Expression::TSNonNullExpression(it) => visitor.visit_ts_non_null_expression(it), + Expression::TSInstantiationExpression(it) => { + visitor.visit_ts_instantiation_expression(it) + } + match_member_expression!(Expression) => { + visitor.visit_member_expression(it.to_member_expression_mut()) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_arrow_function_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ArrowFunctionExpression<'a>, + ) { + visitor.enter_scope({ + let mut flags = ScopeFlags::Function | ScopeFlags::Arrow; + if it.body.has_use_strict_directive() { + flags |= ScopeFlags::StrictMode; + } + flags + }); + let kind = AstType::ArrowFunctionExpression; + visitor.enter_node(kind); + 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); + } + if let Some(return_type) = &mut it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_formal_parameters<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut FormalParameters<'a>, + ) { + let kind = AstType::FormalParameters; + 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.leave_node(kind); + } + + #[inline] + pub fn walk_formal_parameter_list<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, FormalParameter<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_formal_parameter(el); + } + } + + #[inline] + pub fn walk_formal_parameter<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut FormalParameter<'a>, + ) { + let kind = AstType::FormalParameter; + visitor.enter_node(kind); + visitor.visit_binding_pattern(&mut it.pattern); + visitor.visit_decorators(&mut it.decorators); + 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_binding_identifier<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut BindingIdentifier<'a>, + ) { + let kind = AstType::BindingIdentifier; + visitor.enter_node(kind); + 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), + TSType::TSBigIntKeyword(it) => visitor.visit_ts_big_int_keyword(it), + TSType::TSBooleanKeyword(it) => visitor.visit_ts_boolean_keyword(it), + TSType::TSIntrinsicKeyword(it) => visitor.visit_ts_intrinsic_keyword(it), + TSType::TSNeverKeyword(it) => visitor.visit_ts_never_keyword(it), + TSType::TSNullKeyword(it) => visitor.visit_ts_null_keyword(it), + TSType::TSNumberKeyword(it) => visitor.visit_ts_number_keyword(it), + TSType::TSObjectKeyword(it) => visitor.visit_ts_object_keyword(it), + TSType::TSStringKeyword(it) => visitor.visit_ts_string_keyword(it), + TSType::TSSymbolKeyword(it) => visitor.visit_ts_symbol_keyword(it), + TSType::TSUndefinedKeyword(it) => visitor.visit_ts_undefined_keyword(it), + TSType::TSUnknownKeyword(it) => visitor.visit_ts_unknown_keyword(it), + TSType::TSVoidKeyword(it) => visitor.visit_ts_void_keyword(it), + TSType::TSArrayType(it) => visitor.visit_ts_array_type(it), + TSType::TSConditionalType(it) => visitor.visit_ts_conditional_type(it), + TSType::TSConstructorType(it) => visitor.visit_ts_constructor_type(it), + TSType::TSFunctionType(it) => visitor.visit_ts_function_type(it), + TSType::TSImportType(it) => visitor.visit_ts_import_type(it), + TSType::TSIndexedAccessType(it) => visitor.visit_ts_indexed_access_type(it), + TSType::TSInferType(it) => visitor.visit_ts_infer_type(it), + TSType::TSIntersectionType(it) => visitor.visit_ts_intersection_type(it), + TSType::TSLiteralType(it) => visitor.visit_ts_literal_type(it), + TSType::TSMappedType(it) => visitor.visit_ts_mapped_type(it), + TSType::TSNamedTupleMember(it) => visitor.visit_ts_named_tuple_member(it), + TSType::TSQualifiedName(it) => visitor.visit_ts_qualified_name(it), + TSType::TSTemplateLiteralType(it) => visitor.visit_ts_template_literal_type(it), + TSType::TSThisType(it) => visitor.visit_ts_this_type(it), + TSType::TSTupleType(it) => visitor.visit_ts_tuple_type(it), + TSType::TSTypeLiteral(it) => visitor.visit_ts_type_literal(it), + TSType::TSTypeOperatorType(it) => visitor.visit_ts_type_operator(it), + TSType::TSTypePredicate(it) => visitor.visit_ts_type_predicate(it), + TSType::TSTypeQuery(it) => visitor.visit_ts_type_query(it), + TSType::TSTypeReference(it) => visitor.visit_ts_type_reference(it), + TSType::TSUnionType(it) => visitor.visit_ts_union_type(it), + TSType::TSParenthesizedType(it) => visitor.visit_ts_parenthesized_type(it), + TSType::JSDocNullableType(it) => visitor.visit_js_doc_nullable_type(it), + TSType::JSDocNonNullableType(it) => visitor.visit_js_doc_non_nullable_type(it), + TSType::JSDocUnknownType(it) => visitor.visit_js_doc_unknown_type(it), + } + } + + #[inline] + pub fn walk_ts_any_keyword<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSAnyKeyword) { + let kind = AstType::TSAnyKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_big_int_keyword<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSBigIntKeyword) { + let kind = AstType::TSBigIntKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_boolean_keyword<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSBooleanKeyword, + ) { + let kind = AstType::TSBooleanKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_intrinsic_keyword<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSIntrinsicKeyword, + ) { + let kind = AstType::TSIntrinsicKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_never_keyword<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSNeverKeyword) { + let kind = AstType::TSNeverKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_null_keyword<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSNullKeyword) { + let kind = AstType::TSNullKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_number_keyword<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSNumberKeyword) { + let kind = AstType::TSNumberKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_object_keyword<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSObjectKeyword) { + let kind = AstType::TSObjectKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_string_keyword<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSStringKeyword) { + let kind = AstType::TSStringKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_symbol_keyword<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSSymbolKeyword) { + let kind = AstType::TSSymbolKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_undefined_keyword<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSUndefinedKeyword, + ) { + let kind = AstType::TSUndefinedKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_unknown_keyword<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSUnknownKeyword, + ) { + let kind = AstType::TSUnknownKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_void_keyword<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSVoidKeyword) { + let kind = AstType::TSVoidKeyword; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_array_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSArrayType<'a>) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type(&mut it.element_type); + } + + #[inline] + pub fn walk_ts_conditional_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSConditionalType<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type(&mut it.check_type); + visitor.visit_ts_type(&mut it.extends_type); + visitor.visit_ts_type(&mut it.true_type); + visitor.visit_ts_type(&mut it.false_type); + } + + #[inline] + pub fn walk_ts_constructor_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSConstructorType<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_formal_parameters(&mut it.params); + visitor.visit_ts_type_annotation(&mut it.return_type); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + } + + #[inline] + pub fn walk_ts_type_parameter_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypeParameterDeclaration<'a>, + ) { + let kind = AstType::TSTypeParameterDeclaration; + visitor.enter_node(kind); + visitor.visit_ts_type_parameters(&mut it.params); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_parameters<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, TSTypeParameter<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_ts_type_parameter(el); + } + } + + #[inline] + pub fn walk_ts_type_parameter<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypeParameter<'a>, + ) { + visitor.enter_scope(ScopeFlags::empty()); + let kind = AstType::TSTypeParameter; + visitor.enter_node(kind); + visitor.visit_binding_identifier(&mut it.name); + if let Some(constraint) = &mut it.constraint { + visitor.visit_ts_type(constraint); + } + if let Some(default) = &mut it.default { + visitor.visit_ts_type(default); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_ts_function_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSFunctionType<'a>, + ) { + // NOTE: AstType doesn't exists! + if let Some(this_param) = &mut it.this_param { + visitor.visit_ts_this_parameter(this_param); + } + visitor.visit_formal_parameters(&mut it.params); + visitor.visit_ts_type_annotation(&mut it.return_type); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + } + + #[inline] + pub fn walk_ts_this_parameter<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSThisParameter<'a>, + ) { + let kind = AstType::TSThisParameter; + visitor.enter_node(kind); + visitor.visit_identifier_name(&mut it.this); + if let Some(type_annotation) = &mut it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_import_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSImportType<'a>) { + let kind = AstType::TSImportType; + visitor.enter_node(kind); + visitor.visit_ts_type(&mut it.parameter); + if let Some(qualifier) = &mut it.qualifier { + visitor.visit_ts_type_name(qualifier); + } + if let Some(attributes) = &mut it.attributes { + visitor.visit_ts_import_attributes(attributes); + } + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_name<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSTypeName<'a>) { + let kind = AstType::TSTypeName; + visitor.enter_node(kind); + match it { + TSTypeName::IdentifierReference(it) => visitor.visit_identifier_reference(it), + TSTypeName::QualifiedName(it) => visitor.visit_ts_qualified_name(it), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_qualified_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSQualifiedName<'a>, + ) { + let kind = AstType::TSQualifiedName; + visitor.enter_node(kind); + visitor.visit_ts_type_name(&mut it.left); + visitor.visit_identifier_name(&mut it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_import_attributes<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSImportAttributes<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_import_attribute_list(&mut it.elements); + } + + #[inline] + pub fn walk_ts_import_attribute_list<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, TSImportAttribute<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_ts_import_attribute(el); + } + } + + #[inline] + pub fn walk_ts_import_attribute<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSImportAttribute<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_import_attribute_name(&mut it.name); + visitor.visit_expression(&mut it.value); + } + + #[inline] + pub fn walk_ts_import_attribute_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSImportAttributeName<'a>, + ) { + match it { + TSImportAttributeName::Identifier(it) => visitor.visit_identifier_name(it), + TSImportAttributeName::StringLiteral(it) => visitor.visit_string_literal(it), + } + } + + #[inline] + pub fn walk_ts_type_parameter_instantiation<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypeParameterInstantiation<'a>, + ) { + let kind = AstType::TSTypeParameterInstantiation; + visitor.enter_node(kind); + visitor.visit_ts_types(&mut it.params); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_types<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Vec<'a, TSType<'a>>) { + for el in it.iter_mut() { + visitor.visit_ts_type(el); + } + } + + #[inline] + pub fn walk_ts_indexed_access_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSIndexedAccessType<'a>, + ) { + let kind = AstType::TSIndexedAccessType; + visitor.enter_node(kind); + visitor.visit_ts_type(&mut it.object_type); + visitor.visit_ts_type(&mut it.index_type); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_infer_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSInferType<'a>) { + let kind = AstType::TSInferType; + visitor.enter_node(kind); + visitor.visit_ts_type_parameter(&mut it.type_parameter); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_intersection_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSIntersectionType<'a>, + ) { + let kind = AstType::TSIntersectionType; + visitor.enter_node(kind); + visitor.visit_ts_types(&mut it.types); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_literal_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSLiteralType<'a>) { + let kind = AstType::TSLiteralType; + visitor.enter_node(kind); + visitor.visit_ts_literal(&mut it.literal); + visitor.leave_node(kind); + } + + pub fn walk_ts_literal<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSLiteral<'a>) { + match it { + TSLiteral::BooleanLiteral(it) => visitor.visit_boolean_literal(it), + TSLiteral::NullLiteral(it) => visitor.visit_null_literal(it), + TSLiteral::NumericLiteral(it) => visitor.visit_numeric_literal(it), + TSLiteral::BigIntLiteral(it) => visitor.visit_big_int_literal(it), + TSLiteral::RegExpLiteral(it) => visitor.visit_reg_exp_literal(it), + TSLiteral::StringLiteral(it) => visitor.visit_string_literal(it), + TSLiteral::TemplateLiteral(it) => visitor.visit_template_literal(it), + TSLiteral::UnaryExpression(it) => visitor.visit_unary_expression(it), + } + } + + #[inline] + pub fn walk_unary_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut UnaryExpression<'a>, + ) { + let kind = AstType::UnaryExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_mapped_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSMappedType<'a>) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type_parameter(&mut it.type_parameter); + if let Some(name_type) = &mut it.name_type { + visitor.visit_ts_type(name_type); + } + if let Some(type_annotation) = &mut it.type_annotation { + visitor.visit_ts_type(type_annotation); + } + } + + #[inline] + pub fn walk_ts_named_tuple_member<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSNamedTupleMember<'a>, + ) { + let kind = AstType::TSNamedTupleMember; + visitor.enter_node(kind); + visitor.visit_ts_tuple_element(&mut it.element_type); + visitor.visit_identifier_name(&mut it.label); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_tuple_element<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTupleElement<'a>, + ) { + match it { + TSTupleElement::TSOptionalType(it) => visitor.visit_ts_optional_type(it), + TSTupleElement::TSRestType(it) => visitor.visit_ts_rest_type(it), + match_ts_type!(TSTupleElement) => visitor.visit_ts_type(it.to_ts_type_mut()), + } + } + + #[inline] + pub fn walk_ts_optional_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSOptionalType<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type(&mut it.type_annotation); + } + + #[inline] + pub fn walk_ts_rest_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSRestType<'a>) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type(&mut it.type_annotation); + } + + #[inline] + pub fn walk_ts_template_literal_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTemplateLiteralType<'a>, + ) { + let kind = AstType::TSTemplateLiteralType; + visitor.enter_node(kind); + visitor.visit_template_elements(&mut it.quasis); + visitor.visit_ts_types(&mut it.types); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_this_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSThisType) { + let kind = AstType::TSThisType; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_tuple_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSTupleType<'a>) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_tuple_elements(&mut it.element_types); + } + + #[inline] + pub fn walk_ts_tuple_elements<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, TSTupleElement<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_ts_tuple_element(el); + } + } + + #[inline] + pub fn walk_ts_type_literal<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSTypeLiteral<'a>) { + let kind = AstType::TSTypeLiteral; + visitor.enter_node(kind); + visitor.visit_ts_signatures(&mut it.members); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_signatures<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, TSSignature<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_ts_signature(el); + } + } + + #[inline] + pub fn walk_ts_signature<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSSignature<'a>) { + match it { + TSSignature::TSIndexSignature(it) => visitor.visit_ts_index_signature(it), + TSSignature::TSPropertySignature(it) => visitor.visit_ts_property_signature(it), + TSSignature::TSCallSignatureDeclaration(it) => { + visitor.visit_ts_call_signature_declaration(it) + } + TSSignature::TSConstructSignatureDeclaration(it) => { + visitor.visit_ts_construct_signature_declaration(it) + } + TSSignature::TSMethodSignature(it) => visitor.visit_ts_method_signature(it), + } + } + + #[inline] + pub fn walk_ts_index_signature<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSIndexSignature<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_index_signature_names(&mut it.parameters); + visitor.visit_ts_type_annotation(&mut it.type_annotation); + } + + #[inline] + pub fn walk_ts_index_signature_names<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, TSIndexSignatureName<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_ts_index_signature_name(el); + } + } + + #[inline] + pub fn walk_ts_index_signature_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSIndexSignatureName<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type_annotation(&mut it.type_annotation); + } + + #[inline] + pub fn walk_ts_property_signature<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSPropertySignature<'a>, + ) { + let kind = AstType::TSPropertySignature; + visitor.enter_node(kind); + visitor.visit_property_key(&mut it.key); + if let Some(type_annotation) = &mut it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_call_signature_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSCallSignatureDeclaration<'a>, + ) { + // NOTE: AstType doesn't exists! + if let Some(this_param) = &mut it.this_param { + visitor.visit_ts_this_parameter(this_param); + } + visitor.visit_formal_parameters(&mut it.params); + if let Some(return_type) = &mut it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + } + + #[inline] + pub fn walk_ts_construct_signature_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSConstructSignatureDeclaration<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_formal_parameters(&mut it.params); + if let Some(return_type) = &mut it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + } + + #[inline] + pub fn walk_ts_method_signature<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSMethodSignature<'a>, + ) { + let kind = AstType::TSMethodSignature; + visitor.enter_node(kind); + visitor.visit_property_key(&mut it.key); + if let Some(this_param) = &mut it.this_param { + visitor.visit_ts_this_parameter(this_param); + } + visitor.visit_formal_parameters(&mut it.params); + if let Some(return_type) = &mut it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_operator<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypeOperator<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type(&mut it.type_annotation); + } + + #[inline] + pub fn walk_ts_type_predicate<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypePredicate<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type_predicate_name(&mut it.parameter_name); + if let Some(type_annotation) = &mut it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); + } + } + + #[inline] + pub fn walk_ts_type_predicate_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypePredicateName<'a>, + ) { + match it { + TSTypePredicateName::Identifier(it) => visitor.visit_identifier_name(it), + TSTypePredicateName::This(it) => visitor.visit_ts_this_type(it), + } + } + + #[inline] + pub fn walk_ts_type_query<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSTypeQuery<'a>) { + let kind = AstType::TSTypeQuery; + visitor.enter_node(kind); + visitor.visit_ts_type_query_expr_name(&mut it.expr_name); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_query_expr_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypeQueryExprName<'a>, + ) { + match it { + TSTypeQueryExprName::TSImportType(it) => visitor.visit_ts_import_type(it), + match_ts_type_name!(TSTypeQueryExprName) => { + visitor.visit_ts_type_name(it.to_ts_type_name_mut()) + } + } + } + + #[inline] + pub fn walk_ts_type_reference<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypeReference<'a>, + ) { + let kind = AstType::TSTypeReference; + visitor.enter_node(kind); + visitor.visit_ts_type_name(&mut it.type_name); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_union_type<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSUnionType<'a>) { + let kind = AstType::TSUnionType; + visitor.enter_node(kind); + visitor.visit_ts_types(&mut it.types); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_parenthesized_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSParenthesizedType<'a>, + ) { + let kind = AstType::TSParenthesizedType; + visitor.enter_node(kind); + visitor.visit_ts_type(&mut it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_js_doc_nullable_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSDocNullableType<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type(&mut it.type_annotation); + } + + #[inline] + pub fn walk_js_doc_non_nullable_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSDocNonNullableType<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_type(&mut it.type_annotation); + } + + #[inline] + pub fn walk_js_doc_unknown_type<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSDocUnknownType, + ) { + // NOTE: AstType doesn't exists! + } + + #[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; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_function_body<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut FunctionBody<'a>) { + let kind = AstType::FunctionBody; + visitor.enter_node(kind); + visitor.visit_directives(&mut it.directives); + visitor.visit_statements(&mut it.statements); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_assignment_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentExpression<'a>, + ) { + let kind = AstType::AssignmentExpression; + visitor.enter_node(kind); + visitor.visit_assignment_target(&mut it.left); + visitor.visit_expression(&mut it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_assignment_target<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentTarget<'a>, + ) { + let kind = AstType::AssignmentTarget; + visitor.enter_node(kind); + match it { + match_simple_assignment_target!(AssignmentTarget) => { + visitor.visit_simple_assignment_target(it.to_simple_assignment_target_mut()) + } + match_assignment_target_pattern!(AssignmentTarget) => { + visitor.visit_assignment_target_pattern(it.to_assignment_target_pattern_mut()) + } + } + visitor.leave_node(kind); + } + + pub fn walk_simple_assignment_target<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut SimpleAssignmentTarget<'a>, + ) { + let kind = AstType::SimpleAssignmentTarget; + visitor.enter_node(kind); + match it { + SimpleAssignmentTarget::AssignmentTargetIdentifier(it) => { + visitor.visit_identifier_reference(it) + } + SimpleAssignmentTarget::TSAsExpression(it) => visitor.visit_ts_as_expression(it), + SimpleAssignmentTarget::TSSatisfiesExpression(it) => { + visitor.visit_ts_satisfies_expression(it) + } + SimpleAssignmentTarget::TSNonNullExpression(it) => { + visitor.visit_ts_non_null_expression(it) + } + SimpleAssignmentTarget::TSTypeAssertion(it) => visitor.visit_ts_type_assertion(it), + SimpleAssignmentTarget::TSInstantiationExpression(it) => { + visitor.visit_ts_instantiation_expression(it) + } + match_member_expression!(SimpleAssignmentTarget) => { + visitor.visit_member_expression(it.to_member_expression_mut()) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_as_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSAsExpression<'a>, + ) { + let kind = AstType::TSAsExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + visitor.visit_ts_type(&mut it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_satisfies_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSSatisfiesExpression<'a>, + ) { + let kind = AstType::TSSatisfiesExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + visitor.visit_ts_type(&mut it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_non_null_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSNonNullExpression<'a>, + ) { + let kind = AstType::TSNonNullExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_type_assertion<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypeAssertion<'a>, + ) { + let kind = AstType::TSTypeAssertion; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + visitor.visit_ts_type(&mut it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_instantiation_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSInstantiationExpression<'a>, + ) { + let kind = AstType::TSInstantiationExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + visitor.visit_ts_type_parameter_instantiation(&mut it.type_parameters); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_member_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut MemberExpression<'a>, + ) { + let kind = AstType::MemberExpression; + visitor.enter_node(kind); + match it { + MemberExpression::ComputedMemberExpression(it) => { + visitor.visit_computed_member_expression(it) + } + MemberExpression::StaticMemberExpression(it) => { + visitor.visit_static_member_expression(it) + } + MemberExpression::PrivateFieldExpression(it) => { + visitor.visit_private_field_expression(it) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_computed_member_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ComputedMemberExpression<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_expression(&mut it.object); + visitor.visit_expression(&mut it.expression); + } + + #[inline] + pub fn walk_static_member_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut StaticMemberExpression<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_expression(&mut it.object); + visitor.visit_identifier_name(&mut it.property); + } + + #[inline] + pub fn walk_private_field_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut PrivateFieldExpression<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_expression(&mut it.object); + visitor.visit_private_identifier(&mut it.field); + } + + #[inline] + pub fn walk_assignment_target_pattern<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentTargetPattern<'a>, + ) { + match it { + AssignmentTargetPattern::ArrayAssignmentTarget(it) => { + visitor.visit_array_assignment_target(it) + } + AssignmentTargetPattern::ObjectAssignmentTarget(it) => { + visitor.visit_object_assignment_target(it) + } + } + } + + #[inline] + pub fn walk_array_assignment_target<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ArrayAssignmentTarget<'a>, + ) { + // NOTE: AstType doesn't exists! + for elements in it.elements.iter_mut().flatten() { + visitor.visit_assignment_target_maybe_default(elements); + } + if let Some(rest) = &mut it.rest { + visitor.visit_assignment_target_rest(rest); + } + } + + #[inline] + pub fn walk_assignment_target_maybe_default<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentTargetMaybeDefault<'a>, + ) { + match it { + AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(it) => { + visitor.visit_assignment_target_with_default(it) + } + match_assignment_target!(AssignmentTargetMaybeDefault) => { + visitor.visit_assignment_target(it.to_assignment_target_mut()) + } + } + } + + #[inline] + pub fn walk_assignment_target_with_default<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentTargetWithDefault<'a>, + ) { + let kind = AstType::AssignmentTargetWithDefault; + visitor.enter_node(kind); + visitor.visit_assignment_target(&mut it.binding); + visitor.visit_expression(&mut it.init); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_assignment_target_rest<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentTargetRest<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_assignment_target(&mut it.target); + } + + #[inline] + pub fn walk_object_assignment_target<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ObjectAssignmentTarget<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_assignment_target_properties(&mut it.properties); + if let Some(rest) = &mut it.rest { + visitor.visit_assignment_target_rest(rest); + } + } + + #[inline] + pub fn walk_assignment_target_properties<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, AssignmentTargetProperty<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_assignment_target_property(el); + } + } + + #[inline] + pub fn walk_assignment_target_property<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentTargetProperty<'a>, + ) { + match it { + AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(it) => { + visitor.visit_assignment_target_property_identifier(it) + } + AssignmentTargetProperty::AssignmentTargetPropertyProperty(it) => { + visitor.visit_assignment_target_property_property(it) + } + } + } + + #[inline] + pub fn walk_assignment_target_property_identifier<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentTargetPropertyIdentifier<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_identifier_reference(&mut it.binding); + if let Some(init) = &mut it.init { + visitor.visit_expression(init); + } + } + + #[inline] + pub fn walk_assignment_target_property_property<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AssignmentTargetPropertyProperty<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_property_key(&mut it.name); + visitor.visit_assignment_target_maybe_default(&mut it.binding); + } + + #[inline] + pub fn walk_await_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AwaitExpression<'a>, + ) { + let kind = AstType::AwaitExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_binary_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut BinaryExpression<'a>, + ) { + let kind = AstType::BinaryExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.left); + visitor.visit_expression(&mut it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_call_expression<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut CallExpression<'a>) { + let kind = AstType::CallExpression; + visitor.enter_node(kind); + visitor.visit_arguments(&mut it.arguments); + visitor.visit_expression(&mut it.callee); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_arguments<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Vec<'a, Argument<'a>>) { + for el in it.iter_mut() { + visitor.visit_argument(el); + } + } + + #[inline] + pub fn walk_argument<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Argument<'a>) { + let kind = AstType::Argument; + visitor.enter_node(kind); + match it { + Argument::SpreadElement(it) => visitor.visit_spread_element(it), + match_expression!(Argument) => visitor.visit_expression(it.to_expression_mut()), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_chain_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ChainExpression<'a>, + ) { + let kind = AstType::ChainExpression; + visitor.enter_node(kind); + visitor.visit_chain_element(&mut it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_chain_element<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ChainElement<'a>) { + match it { + ChainElement::CallExpression(it) => visitor.visit_call_expression(it), + match_member_expression!(ChainElement) => { + visitor.visit_member_expression(it.to_member_expression_mut()) + } + } + } + + pub fn walk_class<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Class<'a>) { + let kind = AstType::Class; + visitor.enter_node(kind); + visitor.visit_decorators(&mut it.decorators); + visitor.enter_scope(ScopeFlags::StrictMode); + if let Some(id) = &mut it.id { + visitor.visit_binding_identifier(id); + } + if let Some(super_class) = &mut it.super_class { + visitor.visit_class_heritage(super_class); + } + visitor.visit_class_body(&mut it.body); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + if let Some(super_type_parameters) = &mut it.super_type_parameters { + visitor.visit_ts_type_parameter_instantiation(super_type_parameters); + } + if let Some(implements) = &mut it.implements { + visitor.visit_ts_class_implementses(implements); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + pub fn walk_class_heritage<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Expression<'a>) { + let kind = AstType::ClassHeritage; + visitor.enter_node(kind); + match it { + Expression::BooleanLiteral(it) => visitor.visit_boolean_literal(it), + Expression::NullLiteral(it) => visitor.visit_null_literal(it), + Expression::NumericLiteral(it) => visitor.visit_numeric_literal(it), + Expression::BigIntLiteral(it) => visitor.visit_big_int_literal(it), + Expression::RegExpLiteral(it) => visitor.visit_reg_exp_literal(it), + Expression::StringLiteral(it) => visitor.visit_string_literal(it), + Expression::TemplateLiteral(it) => visitor.visit_template_literal(it), + Expression::Identifier(it) => visitor.visit_identifier_reference(it), + Expression::MetaProperty(it) => visitor.visit_meta_property(it), + Expression::Super(it) => visitor.visit_super(it), + Expression::ArrayExpression(it) => visitor.visit_array_expression(it), + Expression::ArrowFunctionExpression(it) => visitor.visit_arrow_function_expression(it), + Expression::AssignmentExpression(it) => visitor.visit_assignment_expression(it), + Expression::AwaitExpression(it) => visitor.visit_await_expression(it), + Expression::BinaryExpression(it) => visitor.visit_binary_expression(it), + Expression::CallExpression(it) => visitor.visit_call_expression(it), + Expression::ChainExpression(it) => visitor.visit_chain_expression(it), + Expression::ClassExpression(it) => visitor.visit_class(it), + Expression::ConditionalExpression(it) => visitor.visit_conditional_expression(it), + Expression::FunctionExpression(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + Expression::ImportExpression(it) => visitor.visit_import_expression(it), + Expression::LogicalExpression(it) => visitor.visit_logical_expression(it), + Expression::NewExpression(it) => visitor.visit_new_expression(it), + Expression::ObjectExpression(it) => visitor.visit_object_expression(it), + Expression::ParenthesizedExpression(it) => visitor.visit_parenthesized_expression(it), + Expression::SequenceExpression(it) => visitor.visit_sequence_expression(it), + Expression::TaggedTemplateExpression(it) => { + visitor.visit_tagged_template_expression(it) + } + Expression::ThisExpression(it) => visitor.visit_this_expression(it), + Expression::UnaryExpression(it) => visitor.visit_unary_expression(it), + Expression::UpdateExpression(it) => visitor.visit_update_expression(it), + Expression::YieldExpression(it) => visitor.visit_yield_expression(it), + Expression::PrivateInExpression(it) => visitor.visit_private_in_expression(it), + Expression::JSXElement(it) => visitor.visit_jsx_element(it), + Expression::JSXFragment(it) => visitor.visit_jsx_fragment(it), + Expression::TSAsExpression(it) => visitor.visit_ts_as_expression(it), + Expression::TSSatisfiesExpression(it) => visitor.visit_ts_satisfies_expression(it), + Expression::TSTypeAssertion(it) => visitor.visit_ts_type_assertion(it), + Expression::TSNonNullExpression(it) => visitor.visit_ts_non_null_expression(it), + Expression::TSInstantiationExpression(it) => { + visitor.visit_ts_instantiation_expression(it) + } + match_member_expression!(Expression) => { + visitor.visit_member_expression(it.to_member_expression_mut()) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_conditional_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ConditionalExpression<'a>, + ) { + let kind = AstType::ConditionalExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.test); + visitor.visit_expression(&mut it.consequent); + visitor.visit_expression(&mut it.alternate); + visitor.leave_node(kind); + } + + pub fn walk_function<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Function<'a>, + flags: Option, + ) { + visitor.enter_scope({ + let mut flags = flags.unwrap_or(ScopeFlags::empty()) | ScopeFlags::Function; + if it.body.as_ref().is_some_and(|body| body.has_use_strict_directive()) { + flags |= ScopeFlags::StrictMode; + } + flags + }); + let kind = AstType::Function; + visitor.enter_node(kind); + if let Some(id) = &mut it.id { + visitor.visit_binding_identifier(id); + } + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + if let Some(this_param) = &mut it.this_param { + visitor.visit_ts_this_parameter(this_param); + } + visitor.visit_formal_parameters(&mut it.params); + if let Some(body) = &mut it.body { + visitor.visit_function_body(body); + } + if let Some(return_type) = &mut it.return_type { + visitor.visit_ts_type_annotation(return_type); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_import_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ImportExpression<'a>, + ) { + let kind = AstType::ImportExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.source); + visitor.visit_expressions(&mut it.arguments); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_logical_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut LogicalExpression<'a>, + ) { + let kind = AstType::LogicalExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.left); + visitor.visit_expression(&mut it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_new_expression<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut NewExpression<'a>) { + let kind = AstType::NewExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.callee); + visitor.visit_arguments(&mut it.arguments); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_object_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ObjectExpression<'a>, + ) { + let kind = AstType::ObjectExpression; + visitor.enter_node(kind); + visitor.visit_object_property_kinds(&mut it.properties); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_object_property_kinds<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, ObjectPropertyKind<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_object_property_kind(el); + } + } + + #[inline] + pub fn walk_object_property_kind<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ObjectPropertyKind<'a>, + ) { + match it { + ObjectPropertyKind::ObjectProperty(it) => visitor.visit_object_property(it), + ObjectPropertyKind::SpreadProperty(it) => visitor.visit_spread_element(it), + } + } + + #[inline] + pub fn walk_object_property<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ObjectProperty<'a>) { + let kind = AstType::ObjectProperty; + visitor.enter_node(kind); + visitor.visit_property_key(&mut it.key); + visitor.visit_expression(&mut it.value); + if let Some(init) = &mut it.init { + visitor.visit_expression(init); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_parenthesized_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ParenthesizedExpression<'a>, + ) { + let kind = AstType::ParenthesizedExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_sequence_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut SequenceExpression<'a>, + ) { + let kind = AstType::SequenceExpression; + visitor.enter_node(kind); + visitor.visit_expressions(&mut it.expressions); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_tagged_template_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TaggedTemplateExpression<'a>, + ) { + let kind = AstType::TaggedTemplateExpression; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.tag); + visitor.visit_template_literal(&mut it.quasi); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_this_expression<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ThisExpression) { + let kind = AstType::ThisExpression; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_update_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut UpdateExpression<'a>, + ) { + let kind = AstType::UpdateExpression; + visitor.enter_node(kind); + visitor.visit_simple_assignment_target(&mut it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_yield_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut YieldExpression<'a>, + ) { + let kind = AstType::YieldExpression; + visitor.enter_node(kind); + if let Some(argument) = &mut it.argument { + visitor.visit_expression(argument); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_private_in_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut PrivateInExpression<'a>, + ) { + let kind = AstType::PrivateInExpression; + visitor.enter_node(kind); + visitor.visit_private_identifier(&mut it.left); + visitor.visit_expression(&mut it.right); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_element<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut JSXElement<'a>) { + let kind = AstType::JSXElement; + visitor.enter_node(kind); + visitor.visit_jsx_opening_element(&mut it.opening_element); + if let Some(closing_element) = &mut it.closing_element { + visitor.visit_jsx_closing_element(closing_element); + } + visitor.visit_jsx_children(&mut it.children); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_opening_element<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXOpeningElement<'a>, + ) { + let kind = AstType::JSXOpeningElement; + visitor.enter_node(kind); + visitor.visit_jsx_element_name(&mut it.name); + visitor.visit_jsx_attribute_items(&mut it.attributes); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_element_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXElementName<'a>, + ) { + let kind = AstType::JSXElementName; + visitor.enter_node(kind); + match it { + JSXElementName::Identifier(it) => visitor.visit_jsx_identifier(it), + JSXElementName::NamespacedName(it) => visitor.visit_jsx_namespaced_name(it), + JSXElementName::MemberExpression(it) => visitor.visit_jsx_member_expression(it), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_identifier<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut JSXIdentifier<'a>) { + let kind = AstType::JSXIdentifier; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_namespaced_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXNamespacedName<'a>, + ) { + let kind = AstType::JSXNamespacedName; + visitor.enter_node(kind); + visitor.visit_jsx_identifier(&mut it.namespace); + visitor.visit_jsx_identifier(&mut it.property); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_member_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXMemberExpression<'a>, + ) { + let kind = AstType::JSXMemberExpression; + visitor.enter_node(kind); + visitor.visit_jsx_member_expression_object(&mut it.object); + visitor.visit_jsx_identifier(&mut it.property); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_member_expression_object<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXMemberExpressionObject<'a>, + ) { + let kind = AstType::JSXMemberExpressionObject; + visitor.enter_node(kind); + match it { + JSXMemberExpressionObject::Identifier(it) => visitor.visit_jsx_identifier(it), + JSXMemberExpressionObject::MemberExpression(it) => { + visitor.visit_jsx_member_expression(it) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_attribute_items<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, JSXAttributeItem<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_jsx_attribute_item(el); + } + } + + #[inline] + pub fn walk_jsx_attribute_item<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXAttributeItem<'a>, + ) { + let kind = AstType::JSXAttributeItem; + visitor.enter_node(kind); + match it { + JSXAttributeItem::Attribute(it) => visitor.visit_jsx_attribute(it), + JSXAttributeItem::SpreadAttribute(it) => visitor.visit_jsx_spread_attribute(it), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_attribute<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut JSXAttribute<'a>) { + // NOTE: AstType doesn't exists! + visitor.visit_jsx_attribute_name(&mut it.name); + if let Some(value) = &mut it.value { + visitor.visit_jsx_attribute_value(value); + } + } + + #[inline] + pub fn walk_jsx_attribute_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXAttributeName<'a>, + ) { + match it { + JSXAttributeName::Identifier(it) => visitor.visit_jsx_identifier(it), + JSXAttributeName::NamespacedName(it) => visitor.visit_jsx_namespaced_name(it), + } + } + + #[inline] + pub fn walk_jsx_attribute_value<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXAttributeValue<'a>, + ) { + match it { + JSXAttributeValue::StringLiteral(it) => visitor.visit_string_literal(it), + JSXAttributeValue::ExpressionContainer(it) => { + visitor.visit_jsx_expression_container(it) + } + JSXAttributeValue::Element(it) => visitor.visit_jsx_element(it), + JSXAttributeValue::Fragment(it) => visitor.visit_jsx_fragment(it), + } + } + + #[inline] + pub fn walk_jsx_expression_container<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXExpressionContainer<'a>, + ) { + let kind = AstType::JSXExpressionContainer; + visitor.enter_node(kind); + visitor.visit_jsx_expression(&mut it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_expression<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut JSXExpression<'a>) { + match it { + JSXExpression::EmptyExpression(it) => visitor.visit_jsx_empty_expression(it), + match_expression!(JSXExpression) => visitor.visit_expression(it.to_expression_mut()), + } + } + + #[inline] + pub fn walk_jsx_empty_expression<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXEmptyExpression, + ) { + // NOTE: AstType doesn't exists! + } + + #[inline] + pub fn walk_jsx_fragment<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut JSXFragment<'a>) { + let kind = AstType::JSXFragment; + visitor.enter_node(kind); + visitor.visit_jsx_children(&mut it.children); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_children<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Vec<'a, JSXChild<'a>>) { + for el in it.iter_mut() { + visitor.visit_jsx_child(el); + } + } + + #[inline] + pub fn walk_jsx_child<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut JSXChild<'a>) { + match it { + JSXChild::Text(it) => visitor.visit_jsx_text(it), + JSXChild::Element(it) => visitor.visit_jsx_element(it), + JSXChild::Fragment(it) => visitor.visit_jsx_fragment(it), + JSXChild::ExpressionContainer(it) => visitor.visit_jsx_expression_container(it), + JSXChild::Spread(it) => visitor.visit_jsx_spread_child(it), + } + } + + #[inline] + pub fn walk_jsx_text<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut JSXText<'a>) { + let kind = AstType::JSXText; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_spread_child<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXSpreadChild<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_expression(&mut it.expression); + } + + #[inline] + pub fn walk_jsx_spread_attribute<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXSpreadAttribute<'a>, + ) { + let kind = AstType::JSXSpreadAttribute; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_jsx_closing_element<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut JSXClosingElement<'a>, + ) { + let kind = AstType::JSXClosingElement; + visitor.enter_node(kind); + visitor.visit_jsx_element_name(&mut it.name); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_class_body<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ClassBody<'a>) { + let kind = AstType::ClassBody; + visitor.enter_node(kind); + visitor.visit_class_elements(&mut it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_class_elements<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, ClassElement<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_class_element(el); + } + } + + #[inline] + pub fn walk_class_element<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ClassElement<'a>) { + match it { + ClassElement::StaticBlock(it) => visitor.visit_static_block(it), + ClassElement::MethodDefinition(it) => visitor.visit_method_definition(it), + ClassElement::PropertyDefinition(it) => visitor.visit_property_definition(it), + ClassElement::AccessorProperty(it) => visitor.visit_accessor_property(it), + ClassElement::TSIndexSignature(it) => visitor.visit_ts_index_signature(it), + } + } + + #[inline] + pub fn walk_static_block<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut StaticBlock<'a>) { + visitor.enter_scope(ScopeFlags::ClassStaticBlock); + let kind = AstType::StaticBlock; + visitor.enter_node(kind); + visitor.visit_statements(&mut it.body); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_method_definition<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut MethodDefinition<'a>, + ) { + let kind = AstType::MethodDefinition; + visitor.enter_node(kind); + visitor.visit_decorators(&mut it.decorators); + visitor.visit_property_key(&mut it.key); + { + let flags = Some(match it.kind { + MethodDefinitionKind::Get => ScopeFlags::GetAccessor, + MethodDefinitionKind::Set => ScopeFlags::SetAccessor, + MethodDefinitionKind::Constructor => ScopeFlags::Constructor, + MethodDefinitionKind::Method => ScopeFlags::empty(), + }); + visitor.visit_function(&mut it.value, flags); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_property_definition<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut PropertyDefinition<'a>, + ) { + let kind = AstType::PropertyDefinition; + visitor.enter_node(kind); + visitor.visit_decorators(&mut it.decorators); + visitor.visit_property_key(&mut it.key); + if let Some(value) = &mut it.value { + visitor.visit_expression(value); + } + if let Some(type_annotation) = &mut it.type_annotation { + visitor.visit_ts_type_annotation(type_annotation); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_accessor_property<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut AccessorProperty<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_property_key(&mut it.key); + if let Some(value) = &mut it.value { + visitor.visit_expression(value); + } + visitor.visit_decorators(&mut it.decorators); + } + + #[inline] + pub fn walk_ts_class_implementses<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, TSClassImplements<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_ts_class_implements(el); + } + } + + #[inline] + pub fn walk_ts_class_implements<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSClassImplements<'a>, + ) { + let kind = AstType::TSClassImplements; + visitor.enter_node(kind); + visitor.visit_ts_type_name(&mut it.expression); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_empty_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut EmptyStatement) { + let kind = AstType::EmptyStatement; + visitor.enter_node(kind); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_expression_statement<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ExpressionStatement<'a>, + ) { + let kind = AstType::ExpressionStatement; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_for_in_statement<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ForInStatement<'a>, + ) { + let scope_events_cond = it.left.is_lexical_declaration(); + if scope_events_cond { + visitor.enter_scope(ScopeFlags::empty()); + } + let kind = AstType::ForInStatement; + visitor.enter_node(kind); + visitor.visit_for_statement_left(&mut it.left); + visitor.visit_expression(&mut it.right); + visitor.visit_statement(&mut it.body); + visitor.leave_node(kind); + if scope_events_cond { + visitor.leave_scope(); + } + } + + #[inline] + pub fn walk_for_statement_left<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ForStatementLeft<'a>, + ) { + match it { + ForStatementLeft::VariableDeclaration(it) => visitor.visit_variable_declaration(it), + ForStatementLeft::UsingDeclaration(it) => visitor.visit_using_declaration(it), + match_assignment_target!(ForStatementLeft) => { + visitor.visit_assignment_target(it.to_assignment_target_mut()) + } + } + } + + #[inline] + pub fn walk_variable_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut VariableDeclaration<'a>, + ) { + let kind = AstType::VariableDeclaration; + visitor.enter_node(kind); + visitor.visit_variable_declarators(&mut it.declarations); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_variable_declarators<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, VariableDeclarator<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_variable_declarator(el); + } + } + + #[inline] + pub fn walk_variable_declarator<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut VariableDeclarator<'a>, + ) { + let kind = AstType::VariableDeclarator; + visitor.enter_node(kind); + visitor.visit_binding_pattern(&mut it.id); + if let Some(init) = &mut it.init { + visitor.visit_expression(init); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_using_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut UsingDeclaration<'a>, + ) { + let kind = AstType::UsingDeclaration; + visitor.enter_node(kind); + visitor.visit_variable_declarators(&mut it.declarations); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_for_of_statement<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ForOfStatement<'a>, + ) { + let scope_events_cond = it.left.is_lexical_declaration(); + if scope_events_cond { + visitor.enter_scope(ScopeFlags::empty()); + } + let kind = AstType::ForOfStatement; + visitor.enter_node(kind); + visitor.visit_for_statement_left(&mut it.left); + visitor.visit_expression(&mut it.right); + visitor.visit_statement(&mut it.body); + visitor.leave_node(kind); + if scope_events_cond { + visitor.leave_scope(); + } + } + + #[inline] + pub fn walk_for_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ForStatement<'a>) { + let scope_events_cond = + it.init.as_ref().is_some_and(ForStatementInit::is_lexical_declaration); + if scope_events_cond { + visitor.enter_scope(ScopeFlags::empty()); + } + let kind = AstType::ForStatement; + visitor.enter_node(kind); + if let Some(init) = &mut it.init { + visitor.visit_for_statement_init(init); + } + if let Some(test) = &mut it.test { + visitor.visit_expression(test); + } + if let Some(update) = &mut it.update { + visitor.visit_expression(update); + } + visitor.visit_statement(&mut it.body); + visitor.leave_node(kind); + if scope_events_cond { + visitor.leave_scope(); + } + } + + #[inline] + pub fn walk_for_statement_init<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ForStatementInit<'a>, + ) { + let kind = AstType::ForStatementInit; + visitor.enter_node(kind); + match it { + ForStatementInit::VariableDeclaration(it) => visitor.visit_variable_declaration(it), + ForStatementInit::UsingDeclaration(it) => visitor.visit_using_declaration(it), + match_expression!(ForStatementInit) => visitor.visit_expression(it.to_expression_mut()), + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_if_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut IfStatement<'a>) { + let kind = AstType::IfStatement; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.test); + visitor.visit_statement(&mut it.consequent); + if let Some(alternate) = &mut it.alternate { + visitor.visit_statement(alternate); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_labeled_statement<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut LabeledStatement<'a>, + ) { + let kind = AstType::LabeledStatement; + visitor.enter_node(kind); + visitor.visit_label_identifier(&mut it.label); + visitor.visit_statement(&mut it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_return_statement<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ReturnStatement<'a>, + ) { + let kind = AstType::ReturnStatement; + visitor.enter_node(kind); + if let Some(argument) = &mut it.argument { + visitor.visit_expression(argument); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_switch_statement<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut SwitchStatement<'a>, + ) { + let kind = AstType::SwitchStatement; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.discriminant); + visitor.enter_scope(ScopeFlags::empty()); + visitor.visit_switch_cases(&mut it.cases); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_switch_cases<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, SwitchCase<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_switch_case(el); + } + } + + #[inline] + pub fn walk_switch_case<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut SwitchCase<'a>) { + let kind = AstType::SwitchCase; + visitor.enter_node(kind); + if let Some(test) = &mut it.test { + visitor.visit_expression(test); + } + visitor.visit_statements(&mut it.consequent); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_throw_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut ThrowStatement<'a>) { + let kind = AstType::ThrowStatement; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.argument); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_try_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TryStatement<'a>) { + let kind = AstType::TryStatement; + visitor.enter_node(kind); + visitor.visit_block_statement(&mut it.block); + if let Some(handler) = &mut it.handler { + visitor.visit_catch_clause(handler); + } + if let Some(finalizer) = &mut it.finalizer { + visitor.visit_finally_clause(finalizer); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_catch_clause<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut CatchClause<'a>) { + let scope_events_cond = it.param.is_some(); + if scope_events_cond { + visitor.enter_scope(ScopeFlags::empty()); + } + let kind = AstType::CatchClause; + visitor.enter_node(kind); + if let Some(param) = &mut it.param { + visitor.visit_catch_parameter(param); + } + visitor.visit_block_statement(&mut it.body); + visitor.leave_node(kind); + if scope_events_cond { + visitor.leave_scope(); + } + } + + #[inline] + pub fn walk_catch_parameter<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut CatchParameter<'a>) { + let kind = AstType::CatchParameter; + visitor.enter_node(kind); + visitor.visit_binding_pattern(&mut it.pattern); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_finally_clause<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut BlockStatement<'a>) { + visitor.enter_scope(ScopeFlags::empty()); + let kind = AstType::FinallyClause; + visitor.enter_node(kind); + visitor.visit_statements(&mut it.body); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_while_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut WhileStatement<'a>) { + let kind = AstType::WhileStatement; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.test); + visitor.visit_statement(&mut it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_with_statement<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut WithStatement<'a>) { + let kind = AstType::WithStatement; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.object); + visitor.visit_statement(&mut it.body); + visitor.leave_node(kind); + } + + pub fn walk_declaration<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut Declaration<'a>) { + match it { + Declaration::VariableDeclaration(it) => visitor.visit_variable_declaration(it), + Declaration::FunctionDeclaration(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + Declaration::ClassDeclaration(it) => visitor.visit_class(it), + Declaration::UsingDeclaration(it) => visitor.visit_using_declaration(it), + Declaration::TSTypeAliasDeclaration(it) => visitor.visit_ts_type_alias_declaration(it), + Declaration::TSInterfaceDeclaration(it) => visitor.visit_ts_interface_declaration(it), + Declaration::TSEnumDeclaration(it) => visitor.visit_ts_enum_declaration(it), + Declaration::TSModuleDeclaration(it) => visitor.visit_ts_module_declaration(it), + Declaration::TSImportEqualsDeclaration(it) => { + visitor.visit_ts_import_equals_declaration(it) + } + } + } + + #[inline] + pub fn walk_ts_type_alias_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSTypeAliasDeclaration<'a>, + ) { + let kind = AstType::TSTypeAliasDeclaration; + visitor.enter_node(kind); + visitor.visit_binding_identifier(&mut it.id); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + visitor.visit_ts_type(&mut it.type_annotation); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_interface_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSInterfaceDeclaration<'a>, + ) { + let kind = AstType::TSInterfaceDeclaration; + visitor.enter_node(kind); + visitor.visit_binding_identifier(&mut it.id); + if let Some(extends) = &mut it.extends { + visitor.visit_ts_interface_heritages(extends); + } + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_declaration(type_parameters); + } + visitor.visit_ts_interface_body(&mut it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_interface_heritages<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, TSInterfaceHeritage<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_ts_interface_heritage(el); + } + } + + #[inline] + pub fn walk_ts_interface_heritage<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSInterfaceHeritage<'a>, + ) { + let kind = AstType::TSInterfaceHeritage; + visitor.enter_node(kind); + visitor.visit_expression(&mut it.expression); + if let Some(type_parameters) = &mut it.type_parameters { + visitor.visit_ts_type_parameter_instantiation(type_parameters); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_interface_body<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSInterfaceBody<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_ts_signatures(&mut it.body); + } + + #[inline] + pub fn walk_ts_enum_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSEnumDeclaration<'a>, + ) { + let kind = AstType::TSEnumDeclaration; + visitor.enter_node(kind); + visitor.visit_binding_identifier(&mut it.id); + visitor.enter_scope(ScopeFlags::empty()); + visitor.visit_ts_enum_members(&mut it.members); + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_ts_enum_members<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, TSEnumMember<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_ts_enum_member(el); + } + } + + #[inline] + pub fn walk_ts_enum_member<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSEnumMember<'a>) { + let kind = AstType::TSEnumMember; + visitor.enter_node(kind); + visitor.visit_ts_enum_member_name(&mut it.id); + if let Some(initializer) = &mut it.initializer { + visitor.visit_expression(initializer); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_enum_member_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSEnumMemberName<'a>, + ) { + match it { + TSEnumMemberName::StaticIdentifier(it) => visitor.visit_identifier_name(it), + TSEnumMemberName::StaticStringLiteral(it) => visitor.visit_string_literal(it), + TSEnumMemberName::StaticNumericLiteral(it) => visitor.visit_numeric_literal(it), + match_expression!(TSEnumMemberName) => visitor.visit_expression(it.to_expression_mut()), + } + } + + #[inline] + pub fn walk_ts_module_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSModuleDeclaration<'a>, + ) { + let kind = AstType::TSModuleDeclaration; + visitor.enter_node(kind); + visitor.visit_ts_module_declaration_name(&mut it.id); + visitor.enter_scope({ + let mut flags = ScopeFlags::TsModuleBlock; + if it.body.as_ref().is_some_and(TSModuleDeclarationBody::is_strict) { + flags |= ScopeFlags::StrictMode; + } + flags + }); + if let Some(body) = &mut it.body { + visitor.visit_ts_module_declaration_body(body); + } + visitor.leave_node(kind); + visitor.leave_scope(); + } + + #[inline] + pub fn walk_ts_module_declaration_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSModuleDeclarationName<'a>, + ) { + match it { + TSModuleDeclarationName::Identifier(it) => visitor.visit_identifier_name(it), + TSModuleDeclarationName::StringLiteral(it) => visitor.visit_string_literal(it), + } + } + + #[inline] + pub fn walk_ts_module_declaration_body<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSModuleDeclarationBody<'a>, + ) { + match it { + TSModuleDeclarationBody::TSModuleDeclaration(it) => { + visitor.visit_ts_module_declaration(it) + } + TSModuleDeclarationBody::TSModuleBlock(it) => visitor.visit_ts_module_block(it), + } + } + + #[inline] + pub fn walk_ts_module_block<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut TSModuleBlock<'a>) { + let kind = AstType::TSModuleBlock; + visitor.enter_node(kind); + visitor.visit_directives(&mut it.directives); + visitor.visit_statements(&mut it.body); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_import_equals_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSImportEqualsDeclaration<'a>, + ) { + let kind = AstType::TSImportEqualsDeclaration; + visitor.enter_node(kind); + visitor.visit_binding_identifier(&mut it.id); + visitor.visit_ts_module_reference(&mut it.module_reference); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_module_reference<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSModuleReference<'a>, + ) { + match it { + TSModuleReference::ExternalModuleReference(it) => { + visitor.visit_ts_external_module_reference(it) + } + match_ts_type_name!(TSModuleReference) => { + visitor.visit_ts_type_name(it.to_ts_type_name_mut()) + } + } + } + + #[inline] + pub fn walk_ts_external_module_reference<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSExternalModuleReference<'a>, + ) { + let kind = AstType::TSExternalModuleReference; + visitor.enter_node(kind); + visitor.visit_string_literal(&mut it.expression); + visitor.leave_node(kind); + } + + pub fn walk_module_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ModuleDeclaration<'a>, + ) { + let kind = AstType::ModuleDeclaration; + visitor.enter_node(kind); + match it { + ModuleDeclaration::ImportDeclaration(it) => visitor.visit_import_declaration(it), + ModuleDeclaration::ExportAllDeclaration(it) => visitor.visit_export_all_declaration(it), + ModuleDeclaration::ExportDefaultDeclaration(it) => { + visitor.visit_export_default_declaration(it) + } + ModuleDeclaration::ExportNamedDeclaration(it) => { + visitor.visit_export_named_declaration(it) + } + ModuleDeclaration::TSExportAssignment(it) => visitor.visit_ts_export_assignment(it), + ModuleDeclaration::TSNamespaceExportDeclaration(it) => { + visitor.visit_ts_namespace_export_declaration(it) + } + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_import_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ImportDeclaration<'a>, + ) { + let kind = AstType::ImportDeclaration; + visitor.enter_node(kind); + if let Some(specifiers) = &mut it.specifiers { + visitor.visit_import_declaration_specifiers(specifiers); + } + visitor.visit_string_literal(&mut it.source); + if let Some(with_clause) = &mut it.with_clause { + visitor.visit_with_clause(with_clause); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_import_declaration_specifiers<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, ImportDeclarationSpecifier<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_import_declaration_specifier(el); + } + } + + #[inline] + pub fn walk_import_declaration_specifier<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ImportDeclarationSpecifier<'a>, + ) { + match it { + ImportDeclarationSpecifier::ImportSpecifier(it) => visitor.visit_import_specifier(it), + ImportDeclarationSpecifier::ImportDefaultSpecifier(it) => { + visitor.visit_import_default_specifier(it) + } + ImportDeclarationSpecifier::ImportNamespaceSpecifier(it) => { + visitor.visit_import_namespace_specifier(it) + } + } + } + + #[inline] + pub fn walk_import_specifier<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ImportSpecifier<'a>, + ) { + let kind = AstType::ImportSpecifier; + visitor.enter_node(kind); + visitor.visit_module_export_name(&mut it.imported); + visitor.visit_binding_identifier(&mut it.local); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_module_export_name<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ModuleExportName<'a>, + ) { + match it { + ModuleExportName::IdentifierName(it) => visitor.visit_identifier_name(it), + ModuleExportName::IdentifierReference(it) => visitor.visit_identifier_reference(it), + ModuleExportName::StringLiteral(it) => visitor.visit_string_literal(it), + } + } + + #[inline] + pub fn walk_import_default_specifier<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ImportDefaultSpecifier<'a>, + ) { + let kind = AstType::ImportDefaultSpecifier; + visitor.enter_node(kind); + visitor.visit_binding_identifier(&mut it.local); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_import_namespace_specifier<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ImportNamespaceSpecifier<'a>, + ) { + let kind = AstType::ImportNamespaceSpecifier; + visitor.enter_node(kind); + visitor.visit_binding_identifier(&mut it.local); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_with_clause<'a, V: VisitMut<'a>>(visitor: &mut V, it: &mut WithClause<'a>) { + // NOTE: AstType doesn't exists! + visitor.visit_identifier_name(&mut it.attributes_keyword); + visitor.visit_import_attributes(&mut it.with_entries); + } + + #[inline] + pub fn walk_import_attributes<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, ImportAttribute<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_import_attribute(el); + } + } + + #[inline] + pub fn walk_import_attribute<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ImportAttribute<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_import_attribute_key(&mut it.key); + visitor.visit_string_literal(&mut it.value); + } + + #[inline] + pub fn walk_import_attribute_key<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ImportAttributeKey<'a>, + ) { + match it { + ImportAttributeKey::Identifier(it) => visitor.visit_identifier_name(it), + ImportAttributeKey::StringLiteral(it) => visitor.visit_string_literal(it), + } + } + + #[inline] + pub fn walk_export_all_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ExportAllDeclaration<'a>, + ) { + let kind = AstType::ExportAllDeclaration; + visitor.enter_node(kind); + if let Some(exported) = &mut it.exported { + visitor.visit_module_export_name(exported); + } + visitor.visit_string_literal(&mut it.source); + if let Some(with_clause) = &mut it.with_clause { + visitor.visit_with_clause(with_clause); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_export_default_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ExportDefaultDeclaration<'a>, + ) { + let kind = AstType::ExportDefaultDeclaration; + visitor.enter_node(kind); + visitor.visit_export_default_declaration_kind(&mut it.declaration); + visitor.visit_module_export_name(&mut it.exported); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_export_default_declaration_kind<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ExportDefaultDeclarationKind<'a>, + ) { + match it { + ExportDefaultDeclarationKind::FunctionDeclaration(it) => { + let flags = None; + visitor.visit_function(it, flags) + } + ExportDefaultDeclarationKind::ClassDeclaration(it) => visitor.visit_class(it), + match_expression!(ExportDefaultDeclarationKind) => { + visitor.visit_expression(it.to_expression_mut()) + } + _ => {} + } + } + + #[inline] + pub fn walk_export_named_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ExportNamedDeclaration<'a>, + ) { + let kind = AstType::ExportNamedDeclaration; + visitor.enter_node(kind); + if let Some(declaration) = &mut it.declaration { + visitor.visit_declaration(declaration); + } + visitor.visit_export_specifiers(&mut it.specifiers); + if let Some(source) = &mut it.source { + visitor.visit_string_literal(source); + } + if let Some(with_clause) = &mut it.with_clause { + visitor.visit_with_clause(with_clause); + } + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_export_specifiers<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut Vec<'a, ExportSpecifier<'a>>, + ) { + for el in it.iter_mut() { + visitor.visit_export_specifier(el); + } + } + + #[inline] + pub fn walk_export_specifier<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut ExportSpecifier<'a>, + ) { + let kind = AstType::ExportSpecifier; + visitor.enter_node(kind); + visitor.visit_module_export_name(&mut it.local); + visitor.visit_module_export_name(&mut it.exported); + visitor.leave_node(kind); + } + + #[inline] + pub fn walk_ts_export_assignment<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSExportAssignment<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_expression(&mut it.expression); + } + + #[inline] + pub fn walk_ts_namespace_export_declaration<'a, V: VisitMut<'a>>( + visitor: &mut V, + it: &mut TSNamespaceExportDeclaration<'a>, + ) { + // NOTE: AstType doesn't exists! + visitor.visit_identifier_name(&mut it.id); + } +} diff --git a/crates/oxc_ast/src/lib.rs b/crates/oxc_ast/src/lib.rs index 95f905f77fa9..60e2ebfc8621 100644 --- a/crates/oxc_ast/src/lib.rs +++ b/crates/oxc_ast/src/lib.rs @@ -1,4 +1,7 @@ #![allow(clippy::wildcard_imports)] +// TODO: I'm not sure if it is a but or intentional but clippy needs this allowed both on this +// module and the generated one. +#![allow(clippy::self_named_module_files)] //! # Oxc AST //! @@ -19,11 +22,17 @@ mod ast_kind_impl; pub mod precedence; pub mod syntax_directed_operations; mod trivia; -pub mod visit; mod generated { pub mod ast_kind; pub mod span; + pub mod visit; + pub mod visit_mut; +} + +pub mod visit { + pub use crate::generated::visit::*; + pub use crate::generated::visit_mut::*; } pub use generated::ast_kind; diff --git a/crates/oxc_ast/src/visit/mod.rs b/crates/oxc_ast/src/visit/mod.rs deleted file mode 100644 index d927a3961f57..000000000000 --- a/crates/oxc_ast/src/visit/mod.rs +++ /dev/null @@ -1,7 +0,0 @@ -#![allow(clippy::module_inception)] - -mod visit; -mod visit_mut; - -pub use visit::*; -pub use visit_mut::*; diff --git a/crates/oxc_ast/src/visit/visit.rs b/crates/oxc_ast/src/visit/visit.rs deleted file mode 100644 index 818ae6d3016c..000000000000 --- a/crates/oxc_ast/src/visit/visit.rs +++ /dev/null @@ -1,3268 +0,0 @@ -//! Visitor Pattern -//! -//! See: -//! * [visitor pattern](https://rust-unofficial.github.io/patterns/patterns/behavioural/visitor.html) -//! * [rustc visitor](https://github.com/rust-lang/rust/blob/master/compiler/rustc_ast/src/visit.rs) - -use oxc_allocator::Vec; -use oxc_syntax::scope::ScopeFlags; -use walk::*; - -use crate::{ast::*, ast_kind::AstKind}; - -/// Syntax tree traversal -pub trait Visit<'a>: Sized { - #[allow(unused_variables)] - fn enter_node(&mut self, kind: AstKind<'a>) {} - #[allow(unused_variables)] - fn leave_node(&mut self, kind: AstKind<'a>) {} - - #[allow(unused_variables)] - fn enter_scope(&mut self, flags: ScopeFlags) {} - fn leave_scope(&mut self) {} - - fn alloc(&self, t: &T) -> &'a T { - // SAFETY: - // This should be safe as long as `src` is an reference from the allocator. - // But honestly, I'm not really sure if this is safe. - #[allow(unsafe_code)] - unsafe { - std::mem::transmute(t) - } - } - - fn visit_program(&mut self, program: &Program<'a>) { - walk_program(self, program); - } - - /* ---------- Statement ---------- */ - - fn visit_statements(&mut self, stmts: &Vec<'a, Statement<'a>>) { - walk_statements(self, stmts); - } - - fn visit_statement(&mut self, stmt: &Statement<'a>) { - walk_statement(self, stmt); - } - - fn visit_block_statement(&mut self, stmt: &BlockStatement<'a>) { - walk_block_statement(self, stmt); - } - - fn visit_break_statement(&mut self, stmt: &BreakStatement<'a>) { - walk_break_statement(self, stmt); - } - - fn visit_continue_statement(&mut self, stmt: &ContinueStatement<'a>) { - walk_continue_statement(self, stmt); - } - - fn visit_debugger_statement(&mut self, stmt: &DebuggerStatement) { - walk_debugger_statement(self, stmt); - } - - fn visit_do_while_statement(&mut self, stmt: &DoWhileStatement<'a>) { - walk_do_while_statement(self, stmt); - } - - fn visit_empty_statement(&mut self, stmt: &EmptyStatement) { - walk_empty_statement(self, stmt); - } - - fn visit_expression_statement(&mut self, stmt: &ExpressionStatement<'a>) { - walk_expression_statement(self, stmt); - } - - fn visit_for_statement(&mut self, stmt: &ForStatement<'a>) { - walk_for_statement(self, stmt); - } - - fn visit_for_statement_init(&mut self, init: &ForStatementInit<'a>) { - walk_for_statement_init(self, init); - } - - fn visit_for_in_statement(&mut self, stmt: &ForInStatement<'a>) { - walk_for_in_statement(self, stmt); - } - - fn visit_for_of_statement(&mut self, stmt: &ForOfStatement<'a>) { - walk_for_of_statement(self, stmt); - } - - fn visit_for_statement_left(&mut self, left: &ForStatementLeft<'a>) { - walk_for_statement_left(self, left); - } - - fn visit_if_statement(&mut self, stmt: &IfStatement<'a>) { - walk_if_statement(self, stmt); - } - - fn visit_labeled_statement(&mut self, stmt: &LabeledStatement<'a>) { - walk_labeled_statement(self, stmt); - } - - fn visit_return_statement(&mut self, stmt: &ReturnStatement<'a>) { - walk_return_statement(self, stmt); - } - - fn visit_switch_statement(&mut self, stmt: &SwitchStatement<'a>) { - walk_switch_statement(self, stmt); - } - - fn visit_switch_case(&mut self, case: &SwitchCase<'a>) { - walk_switch_case(self, case); - } - - fn visit_throw_statement(&mut self, stmt: &ThrowStatement<'a>) { - walk_throw_statement(self, stmt); - } - - fn visit_try_statement(&mut self, stmt: &TryStatement<'a>) { - walk_try_statement(self, stmt); - } - - fn visit_catch_clause(&mut self, clause: &CatchClause<'a>) { - walk_catch_clause(self, clause); - } - - fn visit_catch_parameter(&mut self, param: &CatchParameter<'a>) { - walk_catch_parameter(self, param); - } - - fn visit_finally_clause(&mut self, clause: &BlockStatement<'a>) { - walk_finally_clause(self, clause); - } - - fn visit_while_statement(&mut self, stmt: &WhileStatement<'a>) { - walk_while_statement(self, stmt); - } - - fn visit_with_statement(&mut self, stmt: &WithStatement<'a>) { - walk_with_statement(self, stmt); - } - - fn visit_directive(&mut self, directive: &Directive<'a>) { - walk_directive(self, directive); - } - - /* ---------- Declaration ---------- */ - - fn visit_variable_declaration(&mut self, decl: &VariableDeclaration<'a>) { - walk_variable_declaration(self, decl); - } - - fn visit_variable_declarator(&mut self, declarator: &VariableDeclarator<'a>) { - walk_variable_declarator(self, declarator); - } - - /* ---------- Function ---------- */ - - fn visit_function(&mut self, func: &Function<'a>, flags: Option) { - walk_function(self, func, flags); - } - - fn visit_function_body(&mut self, body: &FunctionBody<'a>) { - walk_function_body(self, body); - } - - fn visit_formal_parameters(&mut self, params: &FormalParameters<'a>) { - walk_formal_parameters(self, params); - } - - fn visit_formal_parameter(&mut self, param: &FormalParameter<'a>) { - walk_formal_parameter(self, param); - } - - /* ---------- Class ---------- */ - - fn visit_decorator(&mut self, decorator: &Decorator<'a>) { - walk_decorator(self, decorator); - } - - fn visit_class(&mut self, class: &Class<'a>) { - walk_class(self, class); - } - - fn visit_class_heritage(&mut self, expr: &Expression<'a>) { - walk_class_heritage(self, expr); - } - - fn visit_ts_class_implements(&mut self, expr: &TSClassImplements<'a>) { - walk_ts_class_implements(self, expr); - } - - fn visit_class_body(&mut self, body: &ClassBody<'a>) { - walk_class_body(self, body); - } - - fn visit_class_element(&mut self, elem: &ClassElement<'a>) { - walk_class_element(self, elem); - } - - fn visit_static_block(&mut self, block: &StaticBlock<'a>) { - walk_static_block(self, block); - } - - fn visit_method_definition(&mut self, def: &MethodDefinition<'a>) { - walk_method_definition(self, def); - } - - fn visit_property_definition(&mut self, def: &PropertyDefinition<'a>) { - walk_property_definition(self, def); - } - - fn visit_using_declaration(&mut self, decl: &UsingDeclaration<'a>) { - walk_using_declaration(self, decl); - } - - /* ---------- Expression ---------- */ - - fn visit_expression(&mut self, expr: &Expression<'a>) { - walk_expression(self, expr); - } - - fn visit_meta_property(&mut self, meta: &MetaProperty<'a>) { - walk_meta_property(self, meta); - } - - fn visit_array_expression(&mut self, expr: &ArrayExpression<'a>) { - walk_array_expression(self, expr); - } - - fn visit_array_expression_element(&mut self, arg: &ArrayExpressionElement<'a>) { - walk_array_expression_element(self, arg); - } - - fn visit_argument(&mut self, arg: &Argument<'a>) { - walk_argument(self, arg); - } - - fn visit_spread_element(&mut self, elem: &SpreadElement<'a>) { - walk_spread_element(self, elem); - } - - fn visit_expression_array_element(&mut self, expr: &Expression<'a>) { - walk_expression_array_element(self, expr); - } - - fn visit_elision(&mut self, elision: &Elision) { - walk_elision(self, elision); - } - - fn visit_assignment_expression(&mut self, expr: &AssignmentExpression<'a>) { - walk_assignment_expression(self, expr); - } - - fn visit_arrow_expression(&mut self, expr: &ArrowFunctionExpression<'a>) { - walk_arrow_expression(self, expr); - } - - fn visit_await_expression(&mut self, expr: &AwaitExpression<'a>) { - walk_await_expression(self, expr); - } - - fn visit_binary_expression(&mut self, expr: &BinaryExpression<'a>) { - walk_binary_expression(self, expr); - } - - fn visit_call_expression(&mut self, expr: &CallExpression<'a>) { - walk_call_expression(self, expr); - } - - fn visit_chain_expression(&mut self, expr: &ChainExpression<'a>) { - walk_chain_expression(self, expr); - } - - fn visit_chain_element(&mut self, elem: &ChainElement<'a>) { - walk_chain_element(self, elem); - } - - fn visit_conditional_expression(&mut self, expr: &ConditionalExpression<'a>) { - walk_conditional_expression(self, expr); - } - - fn visit_import_expression(&mut self, expr: &ImportExpression<'a>) { - walk_import_expression(self, expr); - } - - fn visit_logical_expression(&mut self, expr: &LogicalExpression<'a>) { - walk_logical_expression(self, expr); - } - - fn visit_member_expression(&mut self, expr: &MemberExpression<'a>) { - walk_member_expression(self, expr); - } - - fn visit_computed_member_expression(&mut self, expr: &ComputedMemberExpression<'a>) { - walk_computed_member_expression(self, expr); - } - - fn visit_static_member_expression(&mut self, expr: &StaticMemberExpression<'a>) { - walk_static_member_expression(self, expr); - } - - fn visit_private_field_expression(&mut self, expr: &PrivateFieldExpression<'a>) { - walk_private_field_expression(self, expr); - } - - fn visit_new_expression(&mut self, expr: &NewExpression<'a>) { - walk_new_expression(self, expr); - } - - fn visit_object_expression(&mut self, expr: &ObjectExpression<'a>) { - walk_object_expression(self, expr); - } - - fn visit_object_property_kind(&mut self, prop: &ObjectPropertyKind<'a>) { - walk_object_property_kind(self, prop); - } - - fn visit_object_property(&mut self, prop: &ObjectProperty<'a>) { - walk_object_property(self, prop); - } - - fn visit_property_key(&mut self, key: &PropertyKey<'a>) { - walk_property_key(self, key); - } - - fn visit_parenthesized_expression(&mut self, expr: &ParenthesizedExpression<'a>) { - walk_parenthesized_expression(self, expr); - } - - fn visit_private_in_expression(&mut self, expr: &PrivateInExpression<'a>) { - walk_private_in_expression(self, expr); - } - - fn visit_sequence_expression(&mut self, expr: &SequenceExpression<'a>) { - walk_sequence_expression(self, expr); - } - - fn visit_tagged_template_expression(&mut self, expr: &TaggedTemplateExpression<'a>) { - walk_tagged_template_expression(self, expr); - } - - fn visit_this_expression(&mut self, expr: &ThisExpression) { - walk_this_expression(self, expr); - } - - fn visit_unary_expression(&mut self, expr: &UnaryExpression<'a>) { - walk_unary_expression(self, expr); - } - - fn visit_update_expression(&mut self, expr: &UpdateExpression<'a>) { - walk_update_expression(self, expr); - } - - fn visit_yield_expression(&mut self, expr: &YieldExpression<'a>) { - walk_yield_expression(self, expr); - } - - fn visit_super(&mut self, expr: &Super) { - walk_super(self, expr); - } - - fn visit_assignment_target(&mut self, target: &AssignmentTarget<'a>) { - walk_assignment_target(self, target); - } - - fn visit_simple_assignment_target(&mut self, target: &SimpleAssignmentTarget<'a>) { - walk_simple_assignment_target(self, target); - } - - fn visit_assignment_target_pattern(&mut self, pat: &AssignmentTargetPattern<'a>) { - walk_assignment_target_pattern(self, pat); - } - - fn visit_array_assignment_target(&mut self, target: &ArrayAssignmentTarget<'a>) { - walk_array_assignment_target(self, target); - } - - fn visit_assignment_target_maybe_default(&mut self, target: &AssignmentTargetMaybeDefault<'a>) { - walk_assignment_target_maybe_default(self, target); - } - - fn visit_assignment_target_with_default(&mut self, target: &AssignmentTargetWithDefault<'a>) { - walk_assignment_target_with_default(self, target); - } - - fn visit_object_assignment_target(&mut self, target: &ObjectAssignmentTarget<'a>) { - walk_object_assignment_target(self, target); - } - - fn visit_assignment_target_property(&mut self, property: &AssignmentTargetProperty<'a>) { - walk_assignment_target_property(self, property); - } - - fn visit_assignment_target_property_identifier( - &mut self, - ident: &AssignmentTargetPropertyIdentifier<'a>, - ) { - walk_assignment_target_property_identifier(self, ident); - } - - fn visit_assignment_target_property_property( - &mut self, - property: &AssignmentTargetPropertyProperty<'a>, - ) { - walk_assignment_target_property_property(self, property); - } - - fn visit_assignment_target_rest(&mut self, rest: &AssignmentTargetRest<'a>) { - walk_assignment_target_rest(self, rest); - } - - /* ---------- Expression ---------- */ - - fn visit_jsx_element(&mut self, elem: &JSXElement<'a>) { - walk_jsx_element(self, elem); - } - - fn visit_jsx_opening_element(&mut self, elem: &JSXOpeningElement<'a>) { - walk_jsx_opening_element(self, elem); - } - - fn visit_jsx_closing_element(&mut self, elem: &JSXClosingElement<'a>) { - walk_jsx_closing_element(self, elem); - } - - fn visit_jsx_element_name(&mut self, name: &JSXElementName<'a>) { - walk_jsx_element_name(self, name); - } - - fn visit_jsx_identifier(&mut self, ident: &JSXIdentifier<'a>) { - walk_jsx_identifier(self, ident); - } - - fn visit_jsx_member_expression(&mut self, expr: &JSXMemberExpression<'a>) { - walk_jsx_member_expression(self, expr); - } - - fn visit_jsx_member_expression_object(&mut self, expr: &JSXMemberExpressionObject<'a>) { - walk_jsx_member_expression_object(self, expr); - } - - fn visit_jsx_namespaced_name(&mut self, name: &JSXNamespacedName<'a>) { - walk_jsx_namespaced_name(self, name); - } - - fn visit_jsx_attribute_item(&mut self, item: &JSXAttributeItem<'a>) { - walk_jsx_attribute_item(self, item); - } - - fn visit_jsx_attribute(&mut self, attribute: &JSXAttribute<'a>) { - walk_jsx_attribute(self, attribute); - } - - fn visit_jsx_spread_attribute(&mut self, attribute: &JSXSpreadAttribute<'a>) { - walk_jsx_spread_attribute(self, attribute); - } - - fn visit_jsx_attribute_value(&mut self, value: &JSXAttributeValue<'a>) { - walk_jsx_attribute_value(self, value); - } - - fn visit_jsx_expression_container(&mut self, expr: &JSXExpressionContainer<'a>) { - walk_jsx_expression_container(self, expr); - } - - fn visit_jsx_expression(&mut self, expr: &JSXExpression<'a>) { - walk_jsx_expression(self, expr); - } - - fn visit_jsx_fragment(&mut self, elem: &JSXFragment<'a>) { - walk_jsx_fragment(self, elem); - } - - fn visit_jsx_child(&mut self, child: &JSXChild<'a>) { - walk_jsx_child(self, child); - } - - fn visit_jsx_spread_child(&mut self, child: &JSXSpreadChild<'a>) { - walk_jsx_spread_child(self, child); - } - - fn visit_jsx_text(&mut self, child: &JSXText<'a>) { - walk_jsx_text(self, child); - } - - /* ---------- Pattern ---------- */ - - fn visit_binding_pattern(&mut self, pat: &BindingPattern<'a>) { - walk_binding_pattern(self, pat); - } - - fn visit_binding_identifier(&mut self, ident: &BindingIdentifier<'a>) { - walk_binding_identifier(self, ident); - } - - fn visit_object_pattern(&mut self, pat: &ObjectPattern<'a>) { - walk_object_pattern(self, pat); - } - - fn visit_binding_property(&mut self, prop: &BindingProperty<'a>) { - walk_binding_property(self, prop); - } - - fn visit_array_pattern(&mut self, pat: &ArrayPattern<'a>) { - walk_array_pattern(self, pat); - } - - fn visit_rest_element(&mut self, pat: &BindingRestElement<'a>) { - walk_rest_element(self, pat); - } - - fn visit_assignment_pattern(&mut self, pat: &AssignmentPattern<'a>) { - walk_assignment_pattern(self, pat); - } - - /* ---------- Identifier ---------- */ - - fn visit_identifier_reference(&mut self, ident: &IdentifierReference<'a>) { - walk_identifier_reference(self, ident); - } - - fn visit_private_identifier(&mut self, ident: &PrivateIdentifier<'a>) { - walk_private_identifier(self, ident); - } - - fn visit_label_identifier(&mut self, ident: &LabelIdentifier<'a>) { - walk_label_identifier(self, ident); - } - - fn visit_identifier_name(&mut self, ident: &IdentifierName<'a>) { - walk_identifier_name(self, ident); - } - - /* ---------- Literal ---------- */ - - fn visit_number_literal(&mut self, lit: &NumericLiteral<'a>) { - walk_number_literal(self, lit); - } - - fn visit_boolean_literal(&mut self, lit: &BooleanLiteral) { - walk_boolean_literal(self, lit); - } - - fn visit_null_literal(&mut self, lit: &NullLiteral) { - walk_null_literal(self, lit); - } - - fn visit_bigint_literal(&mut self, lit: &BigIntLiteral<'a>) { - walk_bigint_literal(self, lit); - } - - fn visit_string_literal(&mut self, lit: &StringLiteral<'a>) { - walk_string_literal(self, lit); - } - - fn visit_template_literal(&mut self, lit: &TemplateLiteral<'a>) { - walk_template_literal(self, lit); - } - - fn visit_reg_expr_literal(&mut self, lit: &RegExpLiteral<'a>) { - walk_reg_expr_literal(self, lit); - } - - fn visit_template_element(&mut self, elem: &TemplateElement) { - walk_template_element(self, elem); - } - - /* ---------- Module ---------- */ - - fn visit_module_declaration(&mut self, decl: &ModuleDeclaration<'a>) { - walk_module_declaration(self, decl); - } - - fn visit_import_declaration(&mut self, decl: &ImportDeclaration<'a>) { - walk_import_declaration(self, decl); - } - - fn visit_with_clause(&mut self, with_clause: &WithClause<'a>) { - walk_with_clause(self, with_clause); - } - - fn visit_import_attribute(&mut self, attribute: &ImportAttribute<'a>) { - walk_import_attribute(self, attribute); - } - - fn visit_import_attribute_key(&mut self, key: &ImportAttributeKey<'a>) { - walk_import_attribute_key(self, key); - } - - fn visit_import_declaration_specifier(&mut self, specifier: &ImportDeclarationSpecifier<'a>) { - walk_import_declaration_specifier(self, specifier); - } - - fn visit_import_specifier(&mut self, specifier: &ImportSpecifier<'a>) { - walk_import_specifier(self, specifier); - } - - fn visit_import_default_specifier(&mut self, specifier: &ImportDefaultSpecifier<'a>) { - walk_import_default_specifier(self, specifier); - } - - fn visit_import_name_specifier(&mut self, specifier: &ImportNamespaceSpecifier<'a>) { - walk_import_name_specifier(self, specifier); - } - - fn visit_export_all_declaration(&mut self, decl: &ExportAllDeclaration<'a>) { - walk_export_all_declaration(self, decl); - } - - fn visit_export_default_declaration(&mut self, decl: &ExportDefaultDeclaration<'a>) { - walk_export_default_declaration(self, decl); - } - - fn visit_export_named_declaration(&mut self, decl: &ExportNamedDeclaration<'a>) { - walk_export_named_declaration(self, decl); - } - - fn visit_export_specifier(&mut self, specifier: &ExportSpecifier<'a>) { - walk_export_specifier(self, specifier); - } - - fn visit_module_export_name(&mut self, name: &ModuleExportName<'a>) { - walk_module_export_name(self, name); - } - - fn visit_enum_member(&mut self, member: &TSEnumMember<'a>) { - walk_enum_member(self, member); - } - - fn visit_enum(&mut self, decl: &TSEnumDeclaration<'a>) { - walk_enum(self, decl); - } - - fn visit_declaration(&mut self, decl: &Declaration<'a>) { - walk_declaration(self, decl); - } - - fn visit_ts_import_equals_declaration(&mut self, decl: &TSImportEqualsDeclaration<'a>) { - walk_ts_import_equals_declaration(self, decl); - } - - fn visit_ts_module_reference(&mut self, reference: &TSModuleReference<'a>) { - walk_ts_module_reference(self, reference); - } - - fn visit_ts_type_name(&mut self, name: &TSTypeName<'a>) { - walk_ts_type_name(self, name); - } - - fn visit_ts_external_module_reference(&mut self, reference: &TSExternalModuleReference<'a>) { - walk_ts_external_module_reference(self, reference); - } - - fn visit_ts_module_declaration(&mut self, decl: &TSModuleDeclaration<'a>) { - walk_ts_module_declaration(self, decl); - } - - fn visit_ts_module_block(&mut self, block: &TSModuleBlock<'a>) { - walk_ts_module_block(self, block); - } - - fn visit_ts_type_alias_declaration(&mut self, decl: &TSTypeAliasDeclaration<'a>) { - walk_ts_type_alias_declaration(self, decl); - } - - fn visit_ts_interface_declaration(&mut self, decl: &TSInterfaceDeclaration<'a>) { - walk_ts_interface_declaration(self, decl); - } - - fn visit_ts_interface_heritage(&mut self, heritage: &TSInterfaceHeritage<'a>) { - walk_ts_interface_heritage(self, heritage); - } - - fn visit_ts_as_expression(&mut self, expr: &TSAsExpression<'a>) { - walk_ts_as_expression(self, expr); - } - - fn visit_ts_satisfies_expression(&mut self, expr: &TSSatisfiesExpression<'a>) { - walk_ts_satisfies_expression(self, expr); - } - - fn visit_ts_non_null_expression(&mut self, expr: &TSNonNullExpression<'a>) { - walk_ts_non_null_expression(self, expr); - } - - fn visit_ts_type_assertion(&mut self, expr: &TSTypeAssertion<'a>) { - walk_ts_type_assertion(self, expr); - } - - fn visit_ts_instantiation_expression(&mut self, expr: &TSInstantiationExpression<'a>) { - walk_ts_instantiation_expression(self, expr); - } - - fn visit_ts_type_annotation(&mut self, annotation: &TSTypeAnnotation<'a>) { - walk_ts_type_annotation(self, annotation); - } - - fn visit_ts_type(&mut self, ty: &TSType<'a>) { - walk_ts_type(self, ty); - } - - fn visit_ts_tuple_element(&mut self, ty: &TSTupleElement<'a>) { - walk_ts_tuple_element(self, ty); - } - - fn visit_ts_this_parameter(&mut self, param: &TSThisParameter<'a>) { - walk_ts_this_parameter(self, param); - } - - fn visit_ts_type_parameter(&mut self, ty: &TSTypeParameter<'a>) { - walk_ts_type_parameter(self, ty); - } - - fn visit_ts_type_parameter_instantiation(&mut self, ty: &TSTypeParameterInstantiation<'a>) { - walk_ts_type_parameter_instantiation(self, ty); - } - - fn visit_ts_type_parameter_declaration(&mut self, ty: &TSTypeParameterDeclaration<'a>) { - walk_ts_type_parameter_declaration(self, ty); - } - - fn visit_ts_any_keyword(&mut self, ty: &TSAnyKeyword) { - walk_ts_any_keyword(self, ty); - } - - fn visit_ts_big_int_keyword(&mut self, ty: &TSBigIntKeyword) { - walk_ts_big_int_keyword(self, ty); - } - - fn visit_ts_boolean_keyword(&mut self, ty: &TSBooleanKeyword) { - walk_ts_boolean_keyword(self, ty); - } - - fn visit_ts_intrinsic_keyword(&mut self, ty: &TSIntrinsicKeyword) { - walk_ts_intrinsic_keyword(self, ty); - } - - fn visit_ts_never_keyword(&mut self, ty: &TSNeverKeyword) { - walk_ts_never_keyword(self, ty); - } - - fn visit_ts_null_keyword(&mut self, ty: &TSNullKeyword) { - walk_ts_null_keyword(self, ty); - } - - fn visit_ts_number_keyword(&mut self, ty: &TSNumberKeyword) { - walk_ts_number_keyword(self, ty); - } - - fn visit_ts_object_keyword(&mut self, ty: &TSObjectKeyword) { - walk_ts_object_keyword(self, ty); - } - - fn visit_ts_string_keyword(&mut self, ty: &TSStringKeyword) { - walk_ts_string_keyword(self, ty); - } - - fn visit_ts_symbol_keyword(&mut self, ty: &TSSymbolKeyword) { - walk_ts_symbol_keyword(self, ty); - } - - fn visit_ts_undefined_keyword(&mut self, ty: &TSUndefinedKeyword) { - walk_ts_undefined_keyword(self, ty); - } - - fn visit_ts_unknown_keyword(&mut self, ty: &TSUnknownKeyword) { - walk_ts_unknown_keyword(self, ty); - } - - fn visit_ts_void_keyword(&mut self, ty: &TSVoidKeyword) { - walk_ts_void_keyword(self, ty); - } - - fn visit_ts_array_type(&mut self, ty: &TSArrayType<'a>) { - walk_ts_array_type(self, ty); - } - - fn visit_ts_conditional_type(&mut self, ty: &TSConditionalType<'a>) { - walk_ts_conditional_type(self, ty); - } - - fn visit_ts_constructor_type(&mut self, ty: &TSConstructorType<'a>) { - walk_ts_constructor_type(self, ty); - } - - fn visit_ts_function_type(&mut self, ty: &TSFunctionType<'a>) { - walk_ts_function_type(self, ty); - } - - fn visit_ts_import_type(&mut self, ty: &TSImportType<'a>) { - walk_ts_import_type(self, ty); - } - - fn visit_ts_indexed_access_type(&mut self, ty: &TSIndexedAccessType<'a>) { - walk_ts_indexed_access_type(self, ty); - } - - fn visit_ts_infer_type(&mut self, ty: &TSInferType<'a>) { - walk_ts_infer_type(self, ty); - } - - fn visit_ts_intersection_type(&mut self, ty: &TSIntersectionType<'a>) { - walk_ts_intersection_type(self, ty); - } - - fn visit_ts_literal_type(&mut self, ty: &TSLiteralType<'a>) { - walk_ts_literal_type(self, ty); - } - - fn visit_ts_mapped_type(&mut self, ty: &TSMappedType<'a>) { - walk_ts_mapped_type(self, ty); - } - - fn visit_ts_named_tuple_member(&mut self, ty: &TSNamedTupleMember<'a>) { - walk_ts_named_tuple_member(self, ty); - } - - fn visit_ts_qualified_name(&mut self, name: &TSQualifiedName<'a>) { - walk_ts_qualified_name(self, name); - } - - fn visit_ts_template_literal_type(&mut self, ty: &TSTemplateLiteralType<'a>) { - walk_ts_template_literal_type(self, ty); - } - - fn visit_ts_this_type(&mut self, ty: &TSThisType) { - walk_ts_this_type(self, ty); - } - - fn visit_ts_tuple_type(&mut self, ty: &TSTupleType<'a>) { - walk_ts_tuple_type(self, ty); - } - - fn visit_ts_type_literal(&mut self, ty: &TSTypeLiteral<'a>) { - walk_ts_type_literal(self, ty); - } - - fn visit_ts_type_operator_type(&mut self, ty: &TSTypeOperator<'a>) { - walk_ts_type_operator_type(self, ty); - } - - fn visit_ts_type_predicate(&mut self, ty: &TSTypePredicate<'a>) { - walk_ts_type_predicate(self, ty); - } - - fn visit_ts_type_query(&mut self, ty: &TSTypeQuery<'a>) { - walk_ts_type_query(self, ty); - } - - fn visit_ts_type_reference(&mut self, ty: &TSTypeReference<'a>) { - walk_ts_type_reference(self, ty); - } - - fn visit_ts_union_type(&mut self, ty: &TSUnionType<'a>) { - walk_ts_union_type(self, ty); - } - - fn visit_ts_signature(&mut self, signature: &TSSignature<'a>) { - walk_ts_signature(self, signature); - } - - fn visit_ts_construct_signature_declaration( - &mut self, - signature: &TSConstructSignatureDeclaration<'a>, - ) { - walk_ts_construct_signature_declaration(self, signature); - } - - fn visit_ts_method_signature(&mut self, signature: &TSMethodSignature<'a>) { - walk_ts_method_signature(self, signature); - } - - fn visit_ts_index_signature_name(&mut self, name: &TSIndexSignatureName<'a>) { - walk_ts_index_signature_name(self, name); - } - - fn visit_ts_index_signature(&mut self, signature: &TSIndexSignature<'a>) { - walk_ts_index_signature(self, signature); - } - - fn visit_ts_property_signature(&mut self, signature: &TSPropertySignature<'a>) { - walk_ts_property_signature(self, signature); - } - - fn visit_ts_call_signature_declaration(&mut self, signature: &TSCallSignatureDeclaration<'a>) { - walk_ts_call_signature_declaration(self, signature); - } - - fn visit_ts_import_attributes(&mut self, attributes: &TSImportAttributes<'a>) { - walk_ts_import_attributes(self, attributes); - } - - fn visit_ts_import_attribute(&mut self, attribute: &TSImportAttribute<'a>) { - walk_ts_import_attribute(self, attribute); - } - - fn visit_ts_import_attribute_name(&mut self, name: &TSImportAttributeName<'a>) { - walk_ts_import_attribute_name(self, name); - } -} - -pub mod walk { - use super::*; - - pub fn walk_program<'a, V: Visit<'a>>(visitor: &mut V, program: &Program<'a>) { - let kind = AstKind::Program(visitor.alloc(program)); - visitor.enter_scope({ - let mut flags = ScopeFlags::Top; - if program.is_strict() { - flags |= ScopeFlags::StrictMode; - } - flags - }); - visitor.enter_node(kind); - for directive in &program.directives { - visitor.visit_directive(directive); - } - visitor.visit_statements(&program.body); - visitor.leave_node(kind); - visitor.leave_scope(); - } - - /* ---------- Statement ---------- */ - - pub fn walk_statements<'a, V: Visit<'a>>(visitor: &mut V, stmts: &Vec<'a, Statement<'a>>) { - for stmt in stmts { - visitor.visit_statement(stmt); - } - } - - pub fn walk_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &Statement<'a>) { - match stmt { - Statement::BlockStatement(stmt) => visitor.visit_block_statement(stmt), - Statement::BreakStatement(stmt) => visitor.visit_break_statement(stmt), - Statement::ContinueStatement(stmt) => visitor.visit_continue_statement(stmt), - Statement::DebuggerStatement(stmt) => visitor.visit_debugger_statement(stmt), - Statement::DoWhileStatement(stmt) => visitor.visit_do_while_statement(stmt), - Statement::EmptyStatement(stmt) => visitor.visit_empty_statement(stmt), - Statement::ExpressionStatement(stmt) => visitor.visit_expression_statement(stmt), - Statement::ForInStatement(stmt) => visitor.visit_for_in_statement(stmt), - Statement::ForOfStatement(stmt) => visitor.visit_for_of_statement(stmt), - Statement::ForStatement(stmt) => visitor.visit_for_statement(stmt), - Statement::IfStatement(stmt) => visitor.visit_if_statement(stmt), - Statement::LabeledStatement(stmt) => visitor.visit_labeled_statement(stmt), - Statement::ReturnStatement(stmt) => visitor.visit_return_statement(stmt), - Statement::SwitchStatement(stmt) => visitor.visit_switch_statement(stmt), - Statement::ThrowStatement(stmt) => visitor.visit_throw_statement(stmt), - Statement::TryStatement(stmt) => visitor.visit_try_statement(stmt), - Statement::WhileStatement(stmt) => visitor.visit_while_statement(stmt), - Statement::WithStatement(stmt) => visitor.visit_with_statement(stmt), - - match_module_declaration!(Statement) => { - visitor.visit_module_declaration(stmt.to_module_declaration()); - } - match_declaration!(Statement) => visitor.visit_declaration(stmt.to_declaration()), - } - } - - pub fn walk_block_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &BlockStatement<'a>) { - let kind = AstKind::BlockStatement(visitor.alloc(stmt)); - visitor.enter_scope(ScopeFlags::empty()); - visitor.enter_node(kind); - visitor.visit_statements(&stmt.body); - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_break_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &BreakStatement<'a>) { - let kind = AstKind::BreakStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - if let Some(break_target) = &stmt.label { - visitor.visit_label_identifier(break_target); - } - visitor.leave_node(kind); - } - - pub fn walk_continue_statement<'a, V: Visit<'a>>( - visitor: &mut V, - stmt: &ContinueStatement<'a>, - ) { - let kind = AstKind::ContinueStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - if let Some(continue_target) = &stmt.label { - visitor.visit_label_identifier(continue_target); - } - visitor.leave_node(kind); - } - - pub fn walk_debugger_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &DebuggerStatement) { - let kind = AstKind::DebuggerStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_do_while_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &DoWhileStatement<'a>) { - let kind = AstKind::DoWhileStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.visit_statement(&stmt.body); - visitor.visit_expression(&stmt.test); - visitor.leave_node(kind); - } - - pub fn walk_empty_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &EmptyStatement) { - let kind = AstKind::EmptyStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_expression_statement<'a, V: Visit<'a>>( - visitor: &mut V, - stmt: &ExpressionStatement<'a>, - ) { - let kind = AstKind::ExpressionStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.visit_expression(&stmt.expression); - visitor.leave_node(kind); - } - - pub fn walk_for_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &ForStatement<'a>) { - let kind = AstKind::ForStatement(visitor.alloc(stmt)); - let is_lexical_declaration = - stmt.init.as_ref().is_some_and(ForStatementInit::is_lexical_declaration); - if is_lexical_declaration { - visitor.enter_scope(ScopeFlags::empty()); - } - visitor.enter_node(kind); - if let Some(init) = &stmt.init { - visitor.visit_for_statement_init(init); - } - if let Some(test) = &stmt.test { - visitor.visit_expression(test); - } - if let Some(update) = &stmt.update { - visitor.visit_expression(update); - } - visitor.visit_statement(&stmt.body); - visitor.leave_node(kind); - if is_lexical_declaration { - visitor.leave_scope(); - } - } - - pub fn walk_for_statement_init<'a, V: Visit<'a>>(visitor: &mut V, init: &ForStatementInit<'a>) { - let kind = AstKind::ForStatementInit(visitor.alloc(init)); - visitor.enter_node(kind); - match init { - ForStatementInit::UsingDeclaration(decl) => { - visitor.visit_using_declaration(decl); - } - ForStatementInit::VariableDeclaration(decl) => { - visitor.visit_variable_declaration(decl); - } - match_expression!(ForStatementInit) => visitor.visit_expression(init.to_expression()), - } - visitor.leave_node(kind); - } - - pub fn walk_for_in_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &ForInStatement<'a>) { - let kind = AstKind::ForInStatement(visitor.alloc(stmt)); - let is_lexical_declaration = stmt.left.is_lexical_declaration(); - if is_lexical_declaration { - visitor.enter_scope(ScopeFlags::empty()); - } - visitor.enter_node(kind); - visitor.visit_for_statement_left(&stmt.left); - visitor.visit_expression(&stmt.right); - visitor.visit_statement(&stmt.body); - visitor.leave_node(kind); - if is_lexical_declaration { - visitor.leave_scope(); - } - } - - pub fn walk_for_of_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &ForOfStatement<'a>) { - let kind = AstKind::ForOfStatement(visitor.alloc(stmt)); - let is_lexical_declaration = stmt.left.is_lexical_declaration(); - if is_lexical_declaration { - visitor.enter_scope(ScopeFlags::empty()); - } - visitor.enter_node(kind); - visitor.visit_for_statement_left(&stmt.left); - visitor.visit_expression(&stmt.right); - visitor.visit_statement(&stmt.body); - visitor.leave_node(kind); - if is_lexical_declaration { - visitor.leave_scope(); - } - } - - pub fn walk_for_statement_left<'a, V: Visit<'a>>(visitor: &mut V, left: &ForStatementLeft<'a>) { - match left { - ForStatementLeft::VariableDeclaration(decl) => { - visitor.visit_variable_declaration(decl); - } - match_assignment_target!(ForStatementLeft) => { - visitor.visit_assignment_target(left.to_assignment_target()); - } - ForStatementLeft::UsingDeclaration(decl) => { - visitor.visit_using_declaration(decl); - } - } - } - - pub fn walk_if_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &IfStatement<'a>) { - let kind = AstKind::IfStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.visit_expression(&stmt.test); - visitor.visit_statement(&stmt.consequent); - if let Some(alternate) = &stmt.alternate { - visitor.visit_statement(alternate); - } - visitor.leave_node(kind); - } - - pub fn walk_labeled_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &LabeledStatement<'a>) { - let kind = AstKind::LabeledStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.visit_label_identifier(&stmt.label); - visitor.visit_statement(&stmt.body); - visitor.leave_node(kind); - } - - pub fn walk_return_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &ReturnStatement<'a>) { - let kind = AstKind::ReturnStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - if let Some(arg) = &stmt.argument { - visitor.visit_expression(arg); - } - visitor.leave_node(kind); - } - - pub fn walk_switch_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &SwitchStatement<'a>) { - let kind = AstKind::SwitchStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.visit_expression(&stmt.discriminant); - visitor.enter_scope(ScopeFlags::empty()); - for case in &stmt.cases { - visitor.visit_switch_case(case); - } - visitor.leave_scope(); - visitor.leave_node(kind); - } - - pub fn walk_switch_case<'a, V: Visit<'a>>(visitor: &mut V, case: &SwitchCase<'a>) { - let kind = AstKind::SwitchCase(visitor.alloc(case)); - visitor.enter_node(kind); - if let Some(expr) = &case.test { - visitor.visit_expression(expr); - } - visitor.visit_statements(&case.consequent); - visitor.leave_node(kind); - } - - pub fn walk_throw_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &ThrowStatement<'a>) { - let kind = AstKind::ThrowStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.visit_expression(&stmt.argument); - visitor.leave_node(kind); - } - - pub fn walk_try_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &TryStatement<'a>) { - let kind = AstKind::TryStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.visit_block_statement(&stmt.block); - if let Some(handler) = &stmt.handler { - visitor.visit_catch_clause(handler); - } - if let Some(finalizer) = &stmt.finalizer { - visitor.visit_finally_clause(finalizer); - } - visitor.leave_node(kind); - } - - pub fn walk_catch_clause<'a, V: Visit<'a>>(visitor: &mut V, clause: &CatchClause<'a>) { - let kind = AstKind::CatchClause(visitor.alloc(clause)); - visitor.enter_scope(ScopeFlags::empty()); - visitor.enter_node(kind); - if let Some(param) = &clause.param { - visitor.visit_catch_parameter(param); - } - visitor.visit_statements(&clause.body.body); - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_catch_parameter<'a, V: Visit<'a>>(visitor: &mut V, param: &CatchParameter<'a>) { - let kind = AstKind::CatchParameter(visitor.alloc(param)); - visitor.enter_node(kind); - visitor.visit_binding_pattern(¶m.pattern); - visitor.leave_node(kind); - } - - pub fn walk_finally_clause<'a, V: Visit<'a>>(visitor: &mut V, clause: &BlockStatement<'a>) { - let kind = AstKind::FinallyClause(visitor.alloc(clause)); - visitor.enter_scope(ScopeFlags::empty()); - visitor.enter_node(kind); - visitor.visit_statements(&clause.body); - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_while_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &WhileStatement<'a>) { - let kind = AstKind::WhileStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.visit_expression(&stmt.test); - visitor.visit_statement(&stmt.body); - visitor.leave_node(kind); - } - - pub fn walk_with_statement<'a, V: Visit<'a>>(visitor: &mut V, stmt: &WithStatement<'a>) { - let kind = AstKind::WithStatement(visitor.alloc(stmt)); - visitor.enter_node(kind); - visitor.visit_expression(&stmt.object); - visitor.visit_statement(&stmt.body); - visitor.leave_node(kind); - } - - pub fn walk_directive<'a, V: Visit<'a>>(visitor: &mut V, directive: &Directive<'a>) { - let kind = AstKind::Directive(visitor.alloc(directive)); - visitor.enter_node(kind); - visitor.visit_string_literal(&directive.expression); - visitor.leave_node(kind); - } - - /* ---------- Declaration ---------- */ - - pub fn walk_variable_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &VariableDeclaration<'a>, - ) { - let kind = AstKind::VariableDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - for declarator in &decl.declarations { - visitor.visit_variable_declarator(declarator); - } - visitor.leave_node(kind); - } - - pub fn walk_variable_declarator<'a, V: Visit<'a>>( - visitor: &mut V, - declarator: &VariableDeclarator<'a>, - ) { - let kind = AstKind::VariableDeclarator(visitor.alloc(declarator)); - visitor.enter_node(kind); - visitor.visit_binding_pattern(&declarator.id); - if let Some(init) = &declarator.init { - visitor.visit_expression(init); - } - visitor.leave_node(kind); - } - - /* ---------- Function ---------- */ - - pub fn walk_function<'a, V: Visit<'a>>( - visitor: &mut V, - func: &Function<'a>, - flags: Option, - ) { - let kind = AstKind::Function(visitor.alloc(func)); - visitor.enter_scope({ - let mut flags = flags.unwrap_or(ScopeFlags::empty()) | ScopeFlags::Function; - if func.is_strict() { - flags |= ScopeFlags::StrictMode; - } - flags - }); - visitor.enter_node(kind); - if let Some(ident) = &func.id { - visitor.visit_binding_identifier(ident); - } - if let Some(parameters) = &func.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - if let Some(this_param) = &func.this_param { - visitor.visit_ts_this_parameter(this_param); - } - visitor.visit_formal_parameters(&func.params); - if let Some(body) = &func.body { - visitor.visit_function_body(body); - } - if let Some(annotation) = &func.return_type { - visitor.visit_ts_type_annotation(annotation); - } - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_function_body<'a, V: Visit<'a>>(visitor: &mut V, body: &FunctionBody<'a>) { - let kind = AstKind::FunctionBody(visitor.alloc(body)); - visitor.enter_node(kind); - for directive in &body.directives { - visitor.visit_directive(directive); - } - visitor.visit_statements(&body.statements); - visitor.leave_node(kind); - } - - pub fn walk_formal_parameters<'a, V: Visit<'a>>( - visitor: &mut V, - params: &FormalParameters<'a>, - ) { - let kind = AstKind::FormalParameters(visitor.alloc(params)); - visitor.enter_node(kind); - for param in ¶ms.items { - visitor.visit_formal_parameter(param); - } - if let Some(rest) = ¶ms.rest { - visitor.visit_rest_element(rest); - } - visitor.leave_node(kind); - } - - pub fn walk_formal_parameter<'a, V: Visit<'a>>(visitor: &mut V, param: &FormalParameter<'a>) { - let kind = AstKind::FormalParameter(visitor.alloc(param)); - visitor.enter_node(kind); - for decorator in ¶m.decorators { - visitor.visit_decorator(decorator); - } - visitor.visit_binding_pattern(¶m.pattern); - visitor.leave_node(kind); - } - - /* ---------- Class ---------- */ - - pub fn walk_decorator<'a, V: Visit<'a>>(visitor: &mut V, decorator: &Decorator<'a>) { - let kind = AstKind::Decorator(visitor.alloc(decorator)); - visitor.enter_node(kind); - visitor.visit_expression(&decorator.expression); - visitor.leave_node(kind); - } - - pub fn walk_class<'a, V: Visit<'a>>(visitor: &mut V, class: &Class<'a>) { - // Class level decorators are transpiled as functions outside of the class taking the class - // itvisitor as argument. They should be visited before class is entered. E.g., they inherit - // strict mode from the enclosing scope rather than from class. - for decorator in &class.decorators { - visitor.visit_decorator(decorator); - } - let kind = AstKind::Class(visitor.alloc(class)); - - // FIXME(don): Should we enter a scope when visiting class declarations? - let is_class_expr = class.r#type == ClassType::ClassExpression; - if is_class_expr { - // Class expressions create a temporary scope with the class name as its only variable - // E.g., `let c = class A { foo() { console.log(A) } }` - visitor.enter_scope(ScopeFlags::empty()); - } - - visitor.enter_node(kind); - - if let Some(id) = &class.id { - visitor.visit_binding_identifier(id); - } - if let Some(parameters) = &class.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - - if let Some(super_class) = &class.super_class { - visitor.visit_class_heritage(super_class); - } - if let Some(implements) = &class.implements { - for implement in implements { - visitor.visit_ts_class_implements(implement); - } - } - if let Some(super_parameters) = &class.super_type_parameters { - visitor.visit_ts_type_parameter_instantiation(super_parameters); - } - visitor.visit_class_body(&class.body); - visitor.leave_node(kind); - if is_class_expr { - visitor.leave_scope(); - } - } - - pub fn walk_class_heritage<'a, V: Visit<'a>>(visitor: &mut V, expr: &Expression<'a>) { - let kind = AstKind::ClassHeritage(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(expr); - visitor.leave_node(kind); - } - - pub fn walk_ts_class_implements<'a, V: Visit<'a>>( - visitor: &mut V, - implements: &TSClassImplements<'a>, - ) { - let kind = AstKind::TSClassImplements(visitor.alloc(implements)); - visitor.enter_node(kind); - visitor.visit_ts_type_name(&implements.expression); - if let Some(type_parameters) = &implements.type_parameters { - visitor.visit_ts_type_parameter_instantiation(type_parameters); - } - visitor.leave_node(kind); - } - - pub fn walk_class_body<'a, V: Visit<'a>>(visitor: &mut V, body: &ClassBody<'a>) { - let kind = AstKind::ClassBody(visitor.alloc(body)); - visitor.enter_node(kind); - for elem in &body.body { - visitor.visit_class_element(elem); - } - visitor.leave_node(kind); - } - - pub fn walk_class_element<'a, V: Visit<'a>>(visitor: &mut V, elem: &ClassElement<'a>) { - match elem { - ClassElement::StaticBlock(block) => visitor.visit_static_block(block), - ClassElement::MethodDefinition(def) => visitor.visit_method_definition(def), - ClassElement::PropertyDefinition(def) => visitor.visit_property_definition(def), - ClassElement::AccessorProperty(_def) => { /* TODO */ } - ClassElement::TSIndexSignature(sig) => visitor.visit_ts_index_signature(sig), - } - } - - pub fn walk_static_block<'a, V: Visit<'a>>(visitor: &mut V, block: &StaticBlock<'a>) { - let kind = AstKind::StaticBlock(visitor.alloc(block)); - visitor.enter_scope(ScopeFlags::ClassStaticBlock); - visitor.enter_node(kind); - visitor.visit_statements(&block.body); - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_method_definition<'a, V: Visit<'a>>(visitor: &mut V, def: &MethodDefinition<'a>) { - let kind = AstKind::MethodDefinition(visitor.alloc(def)); - visitor.enter_node(kind); - for decorator in &def.decorators { - visitor.visit_decorator(decorator); - } - let flags = match def.kind { - MethodDefinitionKind::Get => ScopeFlags::GetAccessor, - MethodDefinitionKind::Set => ScopeFlags::SetAccessor, - MethodDefinitionKind::Constructor => ScopeFlags::Constructor, - MethodDefinitionKind::Method => ScopeFlags::empty(), - }; - visitor.visit_property_key(&def.key); - visitor.visit_function(&def.value, Some(flags)); - visitor.leave_node(kind); - } - - pub fn walk_property_definition<'a, V: Visit<'a>>( - visitor: &mut V, - def: &PropertyDefinition<'a>, - ) { - let kind = AstKind::PropertyDefinition(visitor.alloc(def)); - visitor.enter_node(kind); - for decorator in &def.decorators { - visitor.visit_decorator(decorator); - } - visitor.visit_property_key(&def.key); - if let Some(value) = &def.value { - visitor.visit_expression(value); - } - if let Some(annotation) = &def.type_annotation { - visitor.visit_ts_type_annotation(annotation); - } - visitor.leave_node(kind); - } - - pub fn walk_using_declaration<'a, V: Visit<'a>>(visitor: &mut V, decl: &UsingDeclaration<'a>) { - let kind = AstKind::UsingDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - for decl in &decl.declarations { - visitor.visit_variable_declarator(decl); - } - visitor.leave_node(kind); - } - - /* ---------- Expression ---------- */ - - pub fn walk_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &Expression<'a>) { - match expr { - Expression::BigIntLiteral(lit) => visitor.visit_bigint_literal(lit), - Expression::BooleanLiteral(lit) => visitor.visit_boolean_literal(lit), - Expression::NullLiteral(lit) => visitor.visit_null_literal(lit), - Expression::NumericLiteral(lit) => visitor.visit_number_literal(lit), - Expression::RegExpLiteral(lit) => visitor.visit_reg_expr_literal(lit), - Expression::StringLiteral(lit) => visitor.visit_string_literal(lit), - Expression::TemplateLiteral(lit) => visitor.visit_template_literal(lit), - Expression::Identifier(ident) => visitor.visit_identifier_reference(ident), - Expression::MetaProperty(meta) => visitor.visit_meta_property(meta), - - Expression::ArrayExpression(expr) => visitor.visit_array_expression(expr), - Expression::ArrowFunctionExpression(expr) => visitor.visit_arrow_expression(expr), - Expression::AssignmentExpression(expr) => visitor.visit_assignment_expression(expr), - Expression::AwaitExpression(expr) => visitor.visit_await_expression(expr), - Expression::BinaryExpression(expr) => visitor.visit_binary_expression(expr), - Expression::CallExpression(expr) => visitor.visit_call_expression(expr), - Expression::ChainExpression(expr) => visitor.visit_chain_expression(expr), - Expression::ClassExpression(expr) => { - debug_assert_eq!(expr.r#type, ClassType::ClassExpression); - visitor.visit_class(expr); - } - Expression::ConditionalExpression(expr) => visitor.visit_conditional_expression(expr), - Expression::FunctionExpression(expr) => visitor.visit_function(expr, None), - Expression::ImportExpression(expr) => visitor.visit_import_expression(expr), - Expression::LogicalExpression(expr) => visitor.visit_logical_expression(expr), - match_member_expression!(Expression) => { - visitor.visit_member_expression(expr.to_member_expression()); - } - Expression::NewExpression(expr) => visitor.visit_new_expression(expr), - Expression::ObjectExpression(expr) => visitor.visit_object_expression(expr), - Expression::ParenthesizedExpression(expr) => { - visitor.visit_parenthesized_expression(expr); - } - Expression::PrivateInExpression(expr) => visitor.visit_private_in_expression(expr), - Expression::SequenceExpression(expr) => visitor.visit_sequence_expression(expr), - Expression::TaggedTemplateExpression(expr) => { - visitor.visit_tagged_template_expression(expr); - } - Expression::ThisExpression(expr) => visitor.visit_this_expression(expr), - Expression::UnaryExpression(expr) => visitor.visit_unary_expression(expr), - Expression::UpdateExpression(expr) => visitor.visit_update_expression(expr), - Expression::YieldExpression(expr) => visitor.visit_yield_expression(expr), - Expression::Super(expr) => visitor.visit_super(expr), - Expression::JSXElement(elem) => visitor.visit_jsx_element(elem), - Expression::JSXFragment(elem) => visitor.visit_jsx_fragment(elem), - - Expression::TSAsExpression(expr) => visitor.visit_ts_as_expression(expr), - Expression::TSSatisfiesExpression(expr) => visitor.visit_ts_satisfies_expression(expr), - Expression::TSNonNullExpression(expr) => visitor.visit_ts_non_null_expression(expr), - Expression::TSTypeAssertion(expr) => visitor.visit_ts_type_assertion(expr), - Expression::TSInstantiationExpression(expr) => { - visitor.visit_ts_instantiation_expression(expr); - } - } - } - - pub fn walk_meta_property<'a, V: Visit<'a>>(visitor: &mut V, meta: &MetaProperty<'a>) { - let kind = AstKind::MetaProperty(visitor.alloc(meta)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_array_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &ArrayExpression<'a>) { - let kind = AstKind::ArrayExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - for elem in &expr.elements { - visitor.visit_array_expression_element(elem); - } - visitor.leave_node(kind); - } - - pub fn walk_array_expression_element<'a, V: Visit<'a>>( - visitor: &mut V, - arg: &ArrayExpressionElement<'a>, - ) { - let kind = AstKind::ArrayExpressionElement(visitor.alloc(arg)); - visitor.enter_node(kind); - match arg { - ArrayExpressionElement::SpreadElement(spread) => visitor.visit_spread_element(spread), - match_expression!(ArrayExpressionElement) => { - visitor.visit_expression_array_element(arg.to_expression()); - } - ArrayExpressionElement::Elision(elision) => visitor.visit_elision(elision), - } - visitor.leave_node(kind); - } - - pub fn walk_argument<'a, V: Visit<'a>>(visitor: &mut V, arg: &Argument<'a>) { - let kind = AstKind::Argument(visitor.alloc(arg)); - visitor.enter_node(kind); - match arg { - Argument::SpreadElement(spread) => visitor.visit_spread_element(spread), - match_expression!(Argument) => visitor.visit_expression(arg.to_expression()), - } - visitor.leave_node(kind); - } - - pub fn walk_spread_element<'a, V: Visit<'a>>(visitor: &mut V, elem: &SpreadElement<'a>) { - let kind = AstKind::SpreadElement(visitor.alloc(elem)); - visitor.enter_node(kind); - visitor.visit_expression(&elem.argument); - visitor.leave_node(kind); - } - - pub fn walk_expression_array_element<'a, V: Visit<'a>>(visitor: &mut V, expr: &Expression<'a>) { - let kind = AstKind::ExpressionArrayElement(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(expr); - visitor.leave_node(kind); - } - - pub fn walk_elision<'a, V: Visit<'a>>(visitor: &mut V, elision: &Elision) { - let kind = AstKind::Elision(visitor.alloc(elision)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_assignment_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &AssignmentExpression<'a>, - ) { - let kind = AstKind::AssignmentExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_assignment_target(&expr.left); - visitor.visit_expression(&expr.right); - visitor.leave_node(kind); - } - - pub fn walk_arrow_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &ArrowFunctionExpression<'a>, - ) { - let kind = AstKind::ArrowFunctionExpression(visitor.alloc(expr)); - visitor.enter_scope(ScopeFlags::Function | ScopeFlags::Arrow); - visitor.enter_node(kind); - visitor.visit_formal_parameters(&expr.params); - visitor.visit_function_body(&expr.body); - if let Some(parameters) = &expr.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_await_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &AwaitExpression<'a>) { - let kind = AstKind::AwaitExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.argument); - visitor.leave_node(kind); - } - - pub fn walk_binary_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &BinaryExpression<'a>) { - let kind = AstKind::BinaryExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.left); - visitor.visit_expression(&expr.right); - visitor.leave_node(kind); - } - - pub fn walk_call_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &CallExpression<'a>) { - let kind = AstKind::CallExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - for arg in &expr.arguments { - visitor.visit_argument(arg); - } - visitor.visit_expression(&expr.callee); - if let Some(parameters) = &expr.type_parameters { - visitor.visit_ts_type_parameter_instantiation(parameters); - } - visitor.leave_node(kind); - } - - pub fn walk_chain_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &ChainExpression<'a>) { - let kind = AstKind::ChainExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_chain_element(&expr.expression); - visitor.leave_node(kind); - } - - pub fn walk_chain_element<'a, V: Visit<'a>>(visitor: &mut V, elem: &ChainElement<'a>) { - match elem { - ChainElement::CallExpression(expr) => visitor.visit_call_expression(expr), - match_member_expression!(ChainElement) => { - visitor.visit_member_expression(elem.to_member_expression()); - } - } - } - - pub fn walk_conditional_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &ConditionalExpression<'a>, - ) { - let kind = AstKind::ConditionalExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.test); - visitor.visit_expression(&expr.consequent); - visitor.visit_expression(&expr.alternate); - visitor.leave_node(kind); - } - - pub fn walk_import_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &ImportExpression<'a>) { - let kind = AstKind::ImportExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.source); - for arg in &expr.arguments { - visitor.visit_expression(arg); - } - visitor.leave_node(kind); - } - - pub fn walk_logical_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &LogicalExpression<'a>, - ) { - let kind = AstKind::LogicalExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.left); - visitor.visit_expression(&expr.right); - visitor.leave_node(kind); - } - - pub fn walk_member_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &MemberExpression<'a>) { - let kind = AstKind::MemberExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - match expr { - MemberExpression::ComputedMemberExpression(expr) => { - visitor.visit_computed_member_expression(expr); - } - MemberExpression::StaticMemberExpression(expr) => { - visitor.visit_static_member_expression(expr); - } - MemberExpression::PrivateFieldExpression(expr) => { - visitor.visit_private_field_expression(expr); - } - } - visitor.leave_node(kind); - } - - pub fn walk_computed_member_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &ComputedMemberExpression<'a>, - ) { - visitor.visit_expression(&expr.object); - visitor.visit_expression(&expr.expression); - } - - pub fn walk_static_member_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &StaticMemberExpression<'a>, - ) { - visitor.visit_expression(&expr.object); - visitor.visit_identifier_name(&expr.property); - } - - pub fn walk_private_field_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &PrivateFieldExpression<'a>, - ) { - visitor.visit_expression(&expr.object); - visitor.visit_private_identifier(&expr.field); - } - - pub fn walk_new_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &NewExpression<'a>) { - let kind = AstKind::NewExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.callee); - if let Some(parameters) = &expr.type_parameters { - visitor.visit_ts_type_parameter_instantiation(parameters); - } - for arg in &expr.arguments { - visitor.visit_argument(arg); - } - visitor.leave_node(kind); - } - - pub fn walk_object_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &ObjectExpression<'a>) { - let kind = AstKind::ObjectExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - for prop in &expr.properties { - visitor.visit_object_property_kind(prop); - } - visitor.leave_node(kind); - } - - pub fn walk_object_property_kind<'a, V: Visit<'a>>( - visitor: &mut V, - prop: &ObjectPropertyKind<'a>, - ) { - match prop { - ObjectPropertyKind::ObjectProperty(prop) => visitor.visit_object_property(prop), - ObjectPropertyKind::SpreadProperty(elem) => visitor.visit_spread_element(elem), - } - } - - pub fn walk_object_property<'a, V: Visit<'a>>(visitor: &mut V, prop: &ObjectProperty<'a>) { - let kind = AstKind::ObjectProperty(visitor.alloc(prop)); - visitor.enter_node(kind); - visitor.visit_property_key(&prop.key); - visitor.visit_expression(&prop.value); - visitor.leave_node(kind); - } - - pub fn walk_property_key<'a, V: Visit<'a>>(visitor: &mut V, key: &PropertyKey<'a>) { - let kind = AstKind::PropertyKey(visitor.alloc(key)); - visitor.enter_node(kind); - match key { - PropertyKey::StaticIdentifier(ident) => visitor.visit_identifier_name(ident), - PropertyKey::PrivateIdentifier(ident) => visitor.visit_private_identifier(ident), - match_expression!(PropertyKey) => { - visitor.visit_expression(key.to_expression()); - } - } - visitor.leave_node(kind); - } - - pub fn walk_parenthesized_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &ParenthesizedExpression<'a>, - ) { - let kind = AstKind::ParenthesizedExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.expression); - visitor.leave_node(kind); - } - - pub fn walk_private_in_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &PrivateInExpression<'a>, - ) { - let kind = AstKind::PrivateInExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_private_identifier(&expr.left); - visitor.visit_expression(&expr.right); - visitor.leave_node(kind); - } - - pub fn walk_sequence_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &SequenceExpression<'a>, - ) { - let kind = AstKind::SequenceExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - for expr in &expr.expressions { - visitor.visit_expression(expr); - } - visitor.leave_node(kind); - } - - pub fn walk_tagged_template_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &TaggedTemplateExpression<'a>, - ) { - let kind = AstKind::TaggedTemplateExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.tag); - visitor.visit_template_literal(&expr.quasi); - visitor.leave_node(kind); - } - - pub fn walk_this_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &ThisExpression) { - let kind = AstKind::ThisExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_unary_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &UnaryExpression<'a>) { - let kind = AstKind::UnaryExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.argument); - visitor.leave_node(kind); - } - - pub fn walk_update_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &UpdateExpression<'a>) { - let kind = AstKind::UpdateExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_simple_assignment_target(&expr.argument); - visitor.leave_node(kind); - } - - pub fn walk_yield_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &YieldExpression<'a>) { - let kind = AstKind::YieldExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - if let Some(argument) = &expr.argument { - visitor.visit_expression(argument); - } - visitor.leave_node(kind); - } - - pub fn walk_super<'a, V: Visit<'a>>(visitor: &mut V, expr: &Super) { - let kind = AstKind::Super(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_assignment_target<'a, V: Visit<'a>>( - visitor: &mut V, - target: &AssignmentTarget<'a>, - ) { - let kind = AstKind::AssignmentTarget(visitor.alloc(target)); - visitor.enter_node(kind); - match target { - match_simple_assignment_target!(AssignmentTarget) => { - visitor.visit_simple_assignment_target(target.to_simple_assignment_target()); - } - match_assignment_target_pattern!(AssignmentTarget) => { - visitor.visit_assignment_target_pattern(target.to_assignment_target_pattern()); - } - } - visitor.leave_node(kind); - } - - pub fn walk_simple_assignment_target<'a, V: Visit<'a>>( - visitor: &mut V, - target: &SimpleAssignmentTarget<'a>, - ) { - let kind = AstKind::SimpleAssignmentTarget(visitor.alloc(target)); - visitor.enter_node(kind); - match target { - SimpleAssignmentTarget::AssignmentTargetIdentifier(ident) => { - visitor.visit_identifier_reference(ident); - } - match_member_expression!(SimpleAssignmentTarget) => { - visitor.visit_member_expression(target.to_member_expression()); - } - SimpleAssignmentTarget::TSAsExpression(expr) => { - visitor.visit_expression(&expr.expression); - } - SimpleAssignmentTarget::TSSatisfiesExpression(expr) => { - visitor.visit_expression(&expr.expression); - } - SimpleAssignmentTarget::TSNonNullExpression(expr) => { - visitor.visit_expression(&expr.expression); - } - SimpleAssignmentTarget::TSTypeAssertion(expr) => { - visitor.visit_expression(&expr.expression); - } - SimpleAssignmentTarget::TSInstantiationExpression(expr) => { - visitor.visit_expression(&expr.expression); - } - } - visitor.leave_node(kind); - } - - pub fn walk_assignment_target_pattern<'a, V: Visit<'a>>( - visitor: &mut V, - pat: &AssignmentTargetPattern<'a>, - ) { - match pat { - AssignmentTargetPattern::ArrayAssignmentTarget(target) => { - visitor.visit_array_assignment_target(target); - } - AssignmentTargetPattern::ObjectAssignmentTarget(target) => { - visitor.visit_object_assignment_target(target); - } - } - } - - pub fn walk_array_assignment_target<'a, V: Visit<'a>>( - visitor: &mut V, - target: &ArrayAssignmentTarget<'a>, - ) { - for element in target.elements.iter().flatten() { - visitor.visit_assignment_target_maybe_default(element); - } - if let Some(target) = &target.rest { - visitor.visit_assignment_target_rest(target); - } - } - - pub fn walk_assignment_target_maybe_default<'a, V: Visit<'a>>( - visitor: &mut V, - target: &AssignmentTargetMaybeDefault<'a>, - ) { - match target { - match_assignment_target!(AssignmentTargetMaybeDefault) => { - visitor.visit_assignment_target(target.to_assignment_target()); - } - AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(target) => { - visitor.visit_assignment_target_with_default(target); - } - } - } - - pub fn walk_assignment_target_with_default<'a, V: Visit<'a>>( - visitor: &mut V, - target: &AssignmentTargetWithDefault<'a>, - ) { - let kind = AstKind::AssignmentTargetWithDefault(visitor.alloc(target)); - visitor.enter_node(kind); - visitor.visit_assignment_target(&target.binding); - visitor.visit_expression(&target.init); - visitor.leave_node(kind); - } - - pub fn walk_object_assignment_target<'a, V: Visit<'a>>( - visitor: &mut V, - target: &ObjectAssignmentTarget<'a>, - ) { - for property in &target.properties { - visitor.visit_assignment_target_property(property); - } - if let Some(target) = &target.rest { - visitor.visit_assignment_target_rest(target); - } - } - - pub fn walk_assignment_target_property<'a, V: Visit<'a>>( - visitor: &mut V, - property: &AssignmentTargetProperty<'a>, - ) { - match property { - AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(ident) => { - visitor.visit_assignment_target_property_identifier(ident); - } - AssignmentTargetProperty::AssignmentTargetPropertyProperty(prop) => { - visitor.visit_assignment_target_property_property(prop); - } - } - } - - pub fn walk_assignment_target_property_identifier<'a, V: Visit<'a>>( - visitor: &mut V, - ident: &AssignmentTargetPropertyIdentifier<'a>, - ) { - visitor.visit_identifier_reference(&ident.binding); - if let Some(expr) = &ident.init { - visitor.visit_expression(expr); - } - } - - pub fn walk_assignment_target_property_property<'a, V: Visit<'a>>( - visitor: &mut V, - property: &AssignmentTargetPropertyProperty<'a>, - ) { - visitor.visit_property_key(&property.name); - visitor.visit_assignment_target_maybe_default(&property.binding); - } - - pub fn walk_assignment_target_rest<'a, V: Visit<'a>>( - visitor: &mut V, - rest: &AssignmentTargetRest<'a>, - ) { - visitor.visit_assignment_target(&rest.target); - } - - /* ---------- Expression ---------- */ - - pub fn walk_jsx_element<'a, V: Visit<'a>>(visitor: &mut V, elem: &JSXElement<'a>) { - let kind = AstKind::JSXElement(visitor.alloc(elem)); - visitor.enter_node(kind); - visitor.visit_jsx_opening_element(&elem.opening_element); - for child in &elem.children { - visitor.visit_jsx_child(child); - } - if let Some(closing_elem) = &elem.closing_element { - visitor.visit_jsx_closing_element(closing_elem); - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_opening_element<'a, V: Visit<'a>>( - visitor: &mut V, - elem: &JSXOpeningElement<'a>, - ) { - let kind = AstKind::JSXOpeningElement(visitor.alloc(elem)); - visitor.enter_node(kind); - visitor.visit_jsx_element_name(&elem.name); - for attribute in &elem.attributes { - visitor.visit_jsx_attribute_item(attribute); - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_closing_element<'a, V: Visit<'a>>( - visitor: &mut V, - elem: &JSXClosingElement<'a>, - ) { - let kind = AstKind::JSXClosingElement(visitor.alloc(elem)); - visitor.enter_node(kind); - visitor.visit_jsx_element_name(&elem.name); - visitor.leave_node(kind); - } - - pub fn walk_jsx_element_name<'a, V: Visit<'a>>(visitor: &mut V, name: &JSXElementName<'a>) { - let kind = AstKind::JSXElementName(visitor.alloc(name)); - visitor.enter_node(kind); - match name { - JSXElementName::Identifier(ident) => visitor.visit_jsx_identifier(ident), - JSXElementName::NamespacedName(expr) => visitor.visit_jsx_namespaced_name(expr), - JSXElementName::MemberExpression(expr) => visitor.visit_jsx_member_expression(expr), - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_identifier<'a, V: Visit<'a>>(visitor: &mut V, ident: &JSXIdentifier<'a>) { - let kind = AstKind::JSXIdentifier(visitor.alloc(ident)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_jsx_member_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &JSXMemberExpression<'a>, - ) { - let kind = AstKind::JSXMemberExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_jsx_member_expression_object(&expr.object); - visitor.visit_jsx_identifier(&expr.property); - visitor.leave_node(kind); - } - - pub fn walk_jsx_member_expression_object<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &JSXMemberExpressionObject<'a>, - ) { - let kind = AstKind::JSXMemberExpressionObject(visitor.alloc(expr)); - visitor.enter_node(kind); - match expr { - JSXMemberExpressionObject::Identifier(ident) => visitor.visit_jsx_identifier(ident), - JSXMemberExpressionObject::MemberExpression(expr) => { - visitor.visit_jsx_member_expression(expr); - } - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_namespaced_name<'a, V: Visit<'a>>( - visitor: &mut V, - name: &JSXNamespacedName<'a>, - ) { - let kind = AstKind::JSXNamespacedName(visitor.alloc(name)); - visitor.enter_node(kind); - visitor.visit_jsx_identifier(&name.namespace); - visitor.visit_jsx_identifier(&name.property); - visitor.leave_node(kind); - } - - pub fn walk_jsx_attribute_item<'a, V: Visit<'a>>(visitor: &mut V, item: &JSXAttributeItem<'a>) { - let kind = AstKind::JSXAttributeItem(visitor.alloc(item)); - visitor.enter_node(kind); - match &item { - JSXAttributeItem::Attribute(attribute) => visitor.visit_jsx_attribute(attribute), - JSXAttributeItem::SpreadAttribute(attribute) => { - visitor.visit_jsx_spread_attribute(attribute); - } - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_attribute<'a, V: Visit<'a>>(visitor: &mut V, attribute: &JSXAttribute<'a>) { - if let Some(value) = &attribute.value { - visitor.visit_jsx_attribute_value(value); - } - } - - pub fn walk_jsx_spread_attribute<'a, V: Visit<'a>>( - visitor: &mut V, - attribute: &JSXSpreadAttribute<'a>, - ) { - visitor.visit_expression(&attribute.argument); - } - - pub fn walk_jsx_attribute_value<'a, V: Visit<'a>>( - visitor: &mut V, - value: &JSXAttributeValue<'a>, - ) { - match value { - JSXAttributeValue::ExpressionContainer(expr) => { - visitor.visit_jsx_expression_container(expr); - } - JSXAttributeValue::Element(elem) => visitor.visit_jsx_element(elem), - JSXAttributeValue::Fragment(elem) => visitor.visit_jsx_fragment(elem), - JSXAttributeValue::StringLiteral(lit) => visitor.visit_string_literal(lit), - } - } - - pub fn walk_jsx_expression_container<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &JSXExpressionContainer<'a>, - ) { - let kind = AstKind::JSXExpressionContainer(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_jsx_expression(&expr.expression); - visitor.leave_node(kind); - } - - pub fn walk_jsx_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &JSXExpression<'a>) { - match expr { - match_expression!(JSXExpression) => visitor.visit_expression(expr.to_expression()), - JSXExpression::EmptyExpression(_) => {} - } - } - - pub fn walk_jsx_fragment<'a, V: Visit<'a>>(visitor: &mut V, elem: &JSXFragment<'a>) { - let kind = AstKind::JSXFragment(visitor.alloc(elem)); - visitor.enter_node(kind); - for child in &elem.children { - visitor.visit_jsx_child(child); - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_child<'a, V: Visit<'a>>(visitor: &mut V, child: &JSXChild<'a>) { - match child { - JSXChild::Element(elem) => visitor.visit_jsx_element(elem), - JSXChild::Fragment(elem) => visitor.visit_jsx_fragment(elem), - JSXChild::ExpressionContainer(expr) => visitor.visit_jsx_expression_container(expr), - JSXChild::Spread(expr) => visitor.visit_jsx_spread_child(expr), - JSXChild::Text(expr) => visitor.visit_jsx_text(expr), - } - } - - pub fn walk_jsx_spread_child<'a, V: Visit<'a>>(visitor: &mut V, child: &JSXSpreadChild<'a>) { - visitor.visit_expression(&child.expression); - } - - pub fn walk_jsx_text<'a, V: Visit<'a>>(visitor: &mut V, child: &JSXText<'a>) { - let kind = AstKind::JSXText(visitor.alloc(child)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - /* ---------- Pattern ---------- */ - - pub fn walk_binding_pattern<'a, V: Visit<'a>>(visitor: &mut V, pat: &BindingPattern<'a>) { - match &pat.kind { - BindingPatternKind::BindingIdentifier(ident) => { - visitor.visit_binding_identifier(ident); - } - BindingPatternKind::ObjectPattern(pat) => visitor.visit_object_pattern(pat), - BindingPatternKind::ArrayPattern(pat) => visitor.visit_array_pattern(pat), - BindingPatternKind::AssignmentPattern(pat) => visitor.visit_assignment_pattern(pat), - } - if let Some(type_annotation) = &pat.type_annotation { - visitor.visit_ts_type_annotation(type_annotation); - } - } - - pub fn walk_binding_identifier<'a, V: Visit<'a>>( - visitor: &mut V, - ident: &BindingIdentifier<'a>, - ) { - let kind = AstKind::BindingIdentifier(visitor.alloc(ident)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_object_pattern<'a, V: Visit<'a>>(visitor: &mut V, pat: &ObjectPattern<'a>) { - let kind = AstKind::ObjectPattern(visitor.alloc(pat)); - visitor.enter_node(kind); - for prop in &pat.properties { - visitor.visit_binding_property(prop); - } - if let Some(rest) = &pat.rest { - visitor.visit_rest_element(rest); - } - visitor.leave_node(kind); - } - - pub fn walk_binding_property<'a, V: Visit<'a>>(visitor: &mut V, prop: &BindingProperty<'a>) { - visitor.visit_property_key(&prop.key); - visitor.visit_binding_pattern(&prop.value); - } - - pub fn walk_array_pattern<'a, V: Visit<'a>>(visitor: &mut V, pat: &ArrayPattern<'a>) { - let kind = AstKind::ArrayPattern(visitor.alloc(pat)); - visitor.enter_node(kind); - for pat in pat.elements.iter().flatten() { - visitor.visit_binding_pattern(pat); - } - if let Some(rest) = &pat.rest { - visitor.visit_rest_element(rest); - } - visitor.leave_node(kind); - } - - pub fn walk_rest_element<'a, V: Visit<'a>>(visitor: &mut V, pat: &BindingRestElement<'a>) { - let kind = AstKind::BindingRestElement(visitor.alloc(pat)); - visitor.enter_node(kind); - visitor.visit_binding_pattern(&pat.argument); - visitor.leave_node(kind); - } - - pub fn walk_assignment_pattern<'a, V: Visit<'a>>(visitor: &mut V, pat: &AssignmentPattern<'a>) { - let kind = AstKind::AssignmentPattern(visitor.alloc(pat)); - visitor.enter_node(kind); - visitor.visit_binding_pattern(&pat.left); - visitor.visit_expression(&pat.right); - visitor.leave_node(kind); - } - - /* ---------- Identifier ---------- */ - - pub fn walk_identifier_reference<'a, V: Visit<'a>>( - visitor: &mut V, - ident: &IdentifierReference<'a>, - ) { - let kind = AstKind::IdentifierReference(visitor.alloc(ident)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_private_identifier<'a, V: Visit<'a>>( - visitor: &mut V, - ident: &PrivateIdentifier<'a>, - ) { - let kind = AstKind::PrivateIdentifier(visitor.alloc(ident)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_label_identifier<'a, V: Visit<'a>>(visitor: &mut V, ident: &LabelIdentifier<'a>) { - let kind = AstKind::LabelIdentifier(visitor.alloc(ident)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_identifier_name<'a, V: Visit<'a>>(visitor: &mut V, ident: &IdentifierName<'a>) { - let kind = AstKind::IdentifierName(visitor.alloc(ident)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - /* ---------- Literal ---------- */ - - pub fn walk_number_literal<'a, V: Visit<'a>>(visitor: &mut V, lit: &NumericLiteral<'a>) { - let kind = AstKind::NumericLiteral(visitor.alloc(lit)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_boolean_literal<'a, V: Visit<'a>>(visitor: &mut V, lit: &BooleanLiteral) { - let kind = AstKind::BooleanLiteral(visitor.alloc(lit)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_null_literal<'a, V: Visit<'a>>(visitor: &mut V, lit: &NullLiteral) { - let kind = AstKind::NullLiteral(visitor.alloc(lit)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_bigint_literal<'a, V: Visit<'a>>(visitor: &mut V, lit: &BigIntLiteral<'a>) { - let kind = AstKind::BigIntLiteral(visitor.alloc(lit)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_string_literal<'a, V: Visit<'a>>(visitor: &mut V, lit: &StringLiteral<'a>) { - let kind = AstKind::StringLiteral(visitor.alloc(lit)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_template_literal<'a, V: Visit<'a>>(visitor: &mut V, lit: &TemplateLiteral<'a>) { - let kind = AstKind::TemplateLiteral(visitor.alloc(lit)); - visitor.enter_node(kind); - for elem in &lit.quasis { - visitor.visit_template_element(elem); - } - for expr in &lit.expressions { - visitor.visit_expression(expr); - } - visitor.leave_node(kind); - } - - pub fn walk_reg_expr_literal<'a, V: Visit<'a>>(visitor: &mut V, lit: &RegExpLiteral<'a>) { - let kind = AstKind::RegExpLiteral(visitor.alloc(lit)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_template_element<'a, V: Visit<'a>>(_visitor: &mut V, _elem: &TemplateElement) {} - - /* ---------- Module ---------- */ - - pub fn walk_module_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &ModuleDeclaration<'a>, - ) { - let kind = AstKind::ModuleDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - match decl { - ModuleDeclaration::ImportDeclaration(decl) => { - visitor.visit_import_declaration(decl); - } - ModuleDeclaration::ExportAllDeclaration(decl) => { - visitor.visit_export_all_declaration(decl); - } - ModuleDeclaration::ExportDefaultDeclaration(decl) => { - visitor.visit_export_default_declaration(decl); - } - ModuleDeclaration::ExportNamedDeclaration(decl) => { - visitor.visit_export_named_declaration(decl); - } - ModuleDeclaration::TSExportAssignment(decl) => { - visitor.visit_expression(&decl.expression); - } - ModuleDeclaration::TSNamespaceExportDeclaration(_) => {} - } - visitor.leave_node(kind); - } - - pub fn walk_import_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &ImportDeclaration<'a>, - ) { - let kind = AstKind::ImportDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - if let Some(specifiers) = &decl.specifiers { - for specifier in specifiers { - visitor.visit_import_declaration_specifier(specifier); - } - } - visitor.visit_string_literal(&decl.source); - if let Some(with_clause) = &decl.with_clause { - visitor.visit_with_clause(with_clause); - } - visitor.leave_node(kind); - } - - pub fn walk_with_clause<'a, V: Visit<'a>>(visitor: &mut V, with_clause: &WithClause<'a>) { - for attribute in &with_clause.with_entries { - visitor.visit_import_attribute(attribute); - } - } - - pub fn walk_import_attribute<'a, V: Visit<'a>>( - visitor: &mut V, - attribute: &ImportAttribute<'a>, - ) { - visitor.visit_import_attribute_key(&attribute.key); - visitor.visit_string_literal(&attribute.value); - } - - pub fn walk_import_attribute_key<'a, V: Visit<'a>>( - visitor: &mut V, - key: &ImportAttributeKey<'a>, - ) { - match key { - ImportAttributeKey::Identifier(ident) => visitor.visit_identifier_name(ident), - ImportAttributeKey::StringLiteral(ident) => visitor.visit_string_literal(ident), - } - } - - pub fn walk_import_declaration_specifier<'a, V: Visit<'a>>( - visitor: &mut V, - specifier: &ImportDeclarationSpecifier<'a>, - ) { - match &specifier { - ImportDeclarationSpecifier::ImportSpecifier(specifier) => { - visitor.visit_import_specifier(specifier); - } - ImportDeclarationSpecifier::ImportDefaultSpecifier(specifier) => { - visitor.visit_import_default_specifier(specifier); - } - ImportDeclarationSpecifier::ImportNamespaceSpecifier(specifier) => { - visitor.visit_import_name_specifier(specifier); - } - } - } - - pub fn walk_import_specifier<'a, V: Visit<'a>>( - visitor: &mut V, - specifier: &ImportSpecifier<'a>, - ) { - let kind = AstKind::ImportSpecifier(visitor.alloc(specifier)); - visitor.enter_node(kind); - visitor.visit_module_export_name(&specifier.imported); - visitor.visit_binding_identifier(&specifier.local); - visitor.leave_node(kind); - } - - pub fn walk_import_default_specifier<'a, V: Visit<'a>>( - visitor: &mut V, - specifier: &ImportDefaultSpecifier<'a>, - ) { - let kind = AstKind::ImportDefaultSpecifier(visitor.alloc(specifier)); - visitor.enter_node(kind); - visitor.visit_binding_identifier(&specifier.local); - visitor.leave_node(kind); - } - - pub fn walk_import_name_specifier<'a, V: Visit<'a>>( - visitor: &mut V, - specifier: &ImportNamespaceSpecifier<'a>, - ) { - let kind = AstKind::ImportNamespaceSpecifier(visitor.alloc(specifier)); - visitor.enter_node(kind); - visitor.visit_binding_identifier(&specifier.local); - visitor.leave_node(kind); - } - - pub fn walk_export_all_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &ExportAllDeclaration<'a>, - ) { - let kind = AstKind::ExportAllDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - visitor.visit_string_literal(&decl.source); - visitor.leave_node(kind); - } - - pub fn walk_export_default_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &ExportDefaultDeclaration<'a>, - ) { - let kind = AstKind::ExportDefaultDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - match &decl.declaration { - declaration @ match_expression!(ExportDefaultDeclarationKind) => { - visitor.visit_expression(declaration.to_expression()); - } - ExportDefaultDeclarationKind::FunctionDeclaration(func) => { - visitor.visit_function(func, None); - } - ExportDefaultDeclarationKind::ClassDeclaration(class) => visitor.visit_class(class), - _ => {} - } - visitor.leave_node(kind); - } - - pub fn walk_export_named_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &ExportNamedDeclaration<'a>, - ) { - let kind = AstKind::ExportNamedDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - if let Some(decl) = &decl.declaration { - visitor.visit_declaration(decl); - } - for export_specifier in &decl.specifiers { - visitor.visit_export_specifier(export_specifier); - } - if let Some(ref source) = decl.source { - visitor.visit_string_literal(source); - } - visitor.leave_node(kind); - } - - pub fn walk_export_specifier<'a, V: Visit<'a>>( - visitor: &mut V, - specifier: &ExportSpecifier<'a>, - ) { - let kind = AstKind::ExportSpecifier(visitor.alloc(specifier)); - visitor.enter_node(kind); - visitor.visit_module_export_name(&specifier.local); - visitor.visit_module_export_name(&specifier.exported); - visitor.leave_node(kind); - } - - pub fn walk_module_export_name<'a, V: Visit<'a>>(visitor: &mut V, name: &ModuleExportName<'a>) { - match name { - ModuleExportName::IdentifierName(ident) => visitor.visit_identifier_name(ident), - ModuleExportName::IdentifierReference(ident) => { - visitor.visit_identifier_reference(ident); - } - ModuleExportName::StringLiteral(ident) => visitor.visit_string_literal(ident), - } - } - - pub fn walk_enum_member<'a, V: Visit<'a>>(visitor: &mut V, member: &TSEnumMember<'a>) { - let kind = AstKind::TSEnumMember(visitor.alloc(member)); - visitor.enter_node(kind); - - if let Some(initializer) = &member.initializer { - visitor.visit_expression(initializer); - } - - visitor.leave_node(kind); - } - - pub fn walk_enum<'a, V: Visit<'a>>(visitor: &mut V, decl: &TSEnumDeclaration<'a>) { - let kind = AstKind::TSEnumDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - visitor.visit_binding_identifier(&decl.id); - visitor.enter_scope(ScopeFlags::empty()); - for member in &decl.members { - visitor.visit_enum_member(member); - } - visitor.leave_scope(); - visitor.leave_node(kind); - } - - pub fn walk_declaration<'a, V: Visit<'a>>(visitor: &mut V, decl: &Declaration<'a>) { - match decl { - Declaration::VariableDeclaration(decl) => visitor.visit_variable_declaration(decl), - Declaration::FunctionDeclaration(func) => visitor.visit_function(func, None), - Declaration::ClassDeclaration(class) => { - debug_assert_eq!(class.r#type, ClassType::ClassDeclaration); - visitor.visit_class(class); - } - Declaration::UsingDeclaration(decl) => visitor.visit_using_declaration(decl), - Declaration::TSModuleDeclaration(module) => { - visitor.visit_ts_module_declaration(module); - } - Declaration::TSTypeAliasDeclaration(decl) => { - visitor.visit_ts_type_alias_declaration(decl); - } - Declaration::TSEnumDeclaration(decl) => visitor.visit_enum(decl), - Declaration::TSImportEqualsDeclaration(decl) => { - visitor.visit_ts_import_equals_declaration(decl); - } - Declaration::TSInterfaceDeclaration(decl) => { - visitor.visit_ts_interface_declaration(decl); - } - } - } - - /* ---------- TypeScript ---------- */ - - pub fn walk_ts_import_equals_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &TSImportEqualsDeclaration<'a>, - ) { - let kind = AstKind::TSImportEqualsDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - visitor.visit_binding_identifier(&decl.id); - visitor.visit_ts_module_reference(&decl.module_reference); - visitor.leave_node(kind); - } - - pub fn walk_ts_module_reference<'a, V: Visit<'a>>( - visitor: &mut V, - reference: &TSModuleReference<'a>, - ) { - match reference { - match_ts_type_name!(TSModuleReference) => { - visitor.visit_ts_type_name(reference.to_ts_type_name()); - } - TSModuleReference::ExternalModuleReference(reference) => { - visitor.visit_ts_external_module_reference(reference); - } - } - } - - pub fn walk_ts_type_name<'a, V: Visit<'a>>(visitor: &mut V, name: &TSTypeName<'a>) { - let kind = AstKind::TSTypeName(visitor.alloc(name)); - visitor.enter_node(kind); - match &name { - TSTypeName::IdentifierReference(ident) => visitor.visit_identifier_reference(ident), - TSTypeName::QualifiedName(name) => visitor.visit_ts_qualified_name(name), - } - visitor.leave_node(kind); - } - - pub fn walk_ts_external_module_reference<'a, V: Visit<'a>>( - visitor: &mut V, - reference: &TSExternalModuleReference<'a>, - ) { - let kind = AstKind::TSExternalModuleReference(visitor.alloc(reference)); - visitor.enter_node(kind); - visitor.visit_string_literal(&reference.expression); - visitor.leave_node(kind); - } - - pub fn walk_ts_qualified_name<'a, V: Visit<'a>>(visitor: &mut V, name: &TSQualifiedName<'a>) { - let kind = AstKind::TSQualifiedName(visitor.alloc(name)); - visitor.enter_node(kind); - visitor.visit_ts_type_name(&name.left); - visitor.visit_identifier_name(&name.right); - visitor.leave_node(kind); - } - - pub fn walk_ts_module_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &TSModuleDeclaration<'a>, - ) { - let kind = AstKind::TSModuleDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - match &decl.id { - TSModuleDeclarationName::Identifier(ident) => visitor.visit_identifier_name(ident), - TSModuleDeclarationName::StringLiteral(lit) => visitor.visit_string_literal(lit), - } - visitor.enter_scope({ - let mut flags = ScopeFlags::TsModuleBlock; - if decl.is_strict() { - flags |= ScopeFlags::StrictMode; - } - flags - }); - match &decl.body { - Some(TSModuleDeclarationBody::TSModuleDeclaration(decl)) => { - visitor.visit_ts_module_declaration(decl); - } - Some(TSModuleDeclarationBody::TSModuleBlock(block)) => { - visitor.visit_ts_module_block(block); - } - None => {} - } - visitor.leave_scope(); - visitor.leave_node(kind); - } - - pub fn walk_ts_module_block<'a, V: Visit<'a>>(visitor: &mut V, block: &TSModuleBlock<'a>) { - let kind = AstKind::TSModuleBlock(visitor.alloc(block)); - visitor.enter_node(kind); - visitor.visit_statements(&block.body); - visitor.leave_node(kind); - } - - pub fn walk_ts_type_alias_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &TSTypeAliasDeclaration<'a>, - ) { - let kind = AstKind::TSTypeAliasDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - visitor.visit_binding_identifier(&decl.id); - if let Some(parameters) = &decl.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - visitor.visit_ts_type(&decl.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_interface_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - decl: &TSInterfaceDeclaration<'a>, - ) { - let kind = AstKind::TSInterfaceDeclaration(visitor.alloc(decl)); - visitor.enter_node(kind); - visitor.visit_binding_identifier(&decl.id); - if let Some(extends) = &decl.extends { - for extend in extends { - visitor.visit_ts_interface_heritage(extend); - } - } - if let Some(parameters) = &decl.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - for signature in &decl.body.body { - visitor.visit_ts_signature(signature); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_interface_heritage<'a, V: Visit<'a>>( - visitor: &mut V, - heritage: &TSInterfaceHeritage<'a>, - ) { - let kind = AstKind::TSInterfaceHeritage(visitor.alloc(heritage)); - visitor.enter_node(kind); - visitor.visit_expression(&heritage.expression); - if let Some(type_parameters) = &heritage.type_parameters { - visitor.visit_ts_type_parameter_instantiation(type_parameters); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_as_expression<'a, V: Visit<'a>>(visitor: &mut V, expr: &TSAsExpression<'a>) { - let kind = AstKind::TSAsExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.expression); - visitor.visit_ts_type(&expr.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_satisfies_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &TSSatisfiesExpression<'a>, - ) { - let kind = AstKind::TSSatisfiesExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.expression); - visitor.visit_ts_type(&expr.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_non_null_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &TSNonNullExpression<'a>, - ) { - let kind = AstKind::TSNonNullExpression(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.expression); - visitor.leave_node(kind); - } - - pub fn walk_ts_type_assertion<'a, V: Visit<'a>>(visitor: &mut V, expr: &TSTypeAssertion<'a>) { - let kind = AstKind::TSTypeAssertion(visitor.alloc(expr)); - visitor.enter_node(kind); - visitor.visit_expression(&expr.expression); - visitor.visit_ts_type(&expr.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_instantiation_expression<'a, V: Visit<'a>>( - visitor: &mut V, - expr: &TSInstantiationExpression<'a>, - ) { - visitor.visit_expression(&expr.expression); - visitor.visit_ts_type_parameter_instantiation(&expr.type_parameters); - } - - pub fn walk_ts_type_annotation<'a, V: Visit<'a>>( - visitor: &mut V, - annotation: &TSTypeAnnotation<'a>, - ) { - let kind = AstKind::TSTypeAnnotation(visitor.alloc(annotation)); - visitor.enter_node(kind); - visitor.visit_ts_type(&annotation.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSType<'a>) { - match ty { - // Keyword - TSType::TSAnyKeyword(ty) => visitor.visit_ts_any_keyword(ty), - TSType::TSBigIntKeyword(ty) => visitor.visit_ts_big_int_keyword(ty), - TSType::TSBooleanKeyword(ty) => visitor.visit_ts_boolean_keyword(ty), - TSType::TSIntrinsicKeyword(ty) => visitor.visit_ts_intrinsic_keyword(ty), - TSType::TSNeverKeyword(ty) => visitor.visit_ts_never_keyword(ty), - TSType::TSNullKeyword(ty) => visitor.visit_ts_null_keyword(ty), - TSType::TSNumberKeyword(ty) => visitor.visit_ts_number_keyword(ty), - TSType::TSObjectKeyword(ty) => visitor.visit_ts_object_keyword(ty), - TSType::TSStringKeyword(ty) => visitor.visit_ts_string_keyword(ty), - TSType::TSSymbolKeyword(ty) => visitor.visit_ts_symbol_keyword(ty), - TSType::TSUndefinedKeyword(ty) => visitor.visit_ts_undefined_keyword(ty), - TSType::TSUnknownKeyword(ty) => visitor.visit_ts_unknown_keyword(ty), - TSType::TSVoidKeyword(ty) => visitor.visit_ts_void_keyword(ty), - // Compound - TSType::TSArrayType(ty) => visitor.visit_ts_array_type(ty), - TSType::TSConditionalType(ty) => visitor.visit_ts_conditional_type(ty), - TSType::TSConstructorType(ty) => visitor.visit_ts_constructor_type(ty), - TSType::TSFunctionType(ty) => visitor.visit_ts_function_type(ty), - TSType::TSImportType(ty) => visitor.visit_ts_import_type(ty), - TSType::TSIndexedAccessType(ty) => visitor.visit_ts_indexed_access_type(ty), - TSType::TSInferType(ty) => visitor.visit_ts_infer_type(ty), - TSType::TSIntersectionType(ty) => visitor.visit_ts_intersection_type(ty), - TSType::TSLiteralType(ty) => visitor.visit_ts_literal_type(ty), - TSType::TSMappedType(ty) => visitor.visit_ts_mapped_type(ty), - TSType::TSNamedTupleMember(ty) => visitor.visit_ts_named_tuple_member(ty), - TSType::TSQualifiedName(ty) => visitor.visit_ts_qualified_name(ty), - TSType::TSTemplateLiteralType(ty) => visitor.visit_ts_template_literal_type(ty), - TSType::TSThisType(ty) => visitor.visit_ts_this_type(ty), - TSType::TSTupleType(ty) => visitor.visit_ts_tuple_type(ty), - TSType::TSTypeLiteral(ty) => visitor.visit_ts_type_literal(ty), - TSType::TSTypeOperatorType(ty) => visitor.visit_ts_type_operator_type(ty), - TSType::TSTypePredicate(ty) => visitor.visit_ts_type_predicate(ty), - TSType::TSTypeQuery(ty) => visitor.visit_ts_type_query(ty), - TSType::TSTypeReference(ty) => visitor.visit_ts_type_reference(ty), - TSType::TSUnionType(ty) => visitor.visit_ts_union_type(ty), - TSType::TSParenthesizedType(ty) => visitor.visit_ts_type(&ty.type_annotation), - // JSDoc - TSType::JSDocNullableType(_) - | TSType::JSDocNonNullableType(_) - | TSType::JSDocUnknownType(_) => { /* TODO */ } - } - } - - pub fn walk_ts_type_literal<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSTypeLiteral<'a>) { - let kind = AstKind::TSTypeLiteral(visitor.alloc(ty)); - visitor.enter_node(kind); - for signature in &ty.members { - visitor.visit_ts_signature(signature); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_indexed_access_type<'a, V: Visit<'a>>( - visitor: &mut V, - ty: &TSIndexedAccessType<'a>, - ) { - let kind = AstKind::TSIndexedAccessType(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.visit_ts_type(&ty.object_type); - visitor.visit_ts_type(&ty.index_type); - visitor.leave_node(kind); - } - - pub fn walk_ts_type_predicate<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSTypePredicate<'a>) { - if let Some(annotation) = &ty.type_annotation { - visitor.visit_ts_type_annotation(annotation); - } - } - - pub fn walk_ts_type_operator_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSTypeOperator<'a>) { - visitor.visit_ts_type(&ty.type_annotation); - } - - pub fn walk_ts_tuple_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSTupleType<'a>) { - for element in &ty.element_types { - visitor.visit_ts_tuple_element(element); - } - } - - pub fn walk_ts_tuple_element<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSTupleElement<'a>) { - match ty { - match_ts_type!(TSTupleElement) => visitor.visit_ts_type(ty.to_ts_type()), - TSTupleElement::TSOptionalType(ty) => visitor.visit_ts_type(&ty.type_annotation), - TSTupleElement::TSRestType(ty) => visitor.visit_ts_type(&ty.type_annotation), - }; - } - - pub fn walk_ts_mapped_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSMappedType<'a>) { - visitor.visit_ts_type_parameter(&ty.type_parameter); - if let Some(name) = &ty.name_type { - visitor.visit_ts_type(name); - } - if let Some(type_annotation) = &ty.type_annotation { - visitor.visit_ts_type(type_annotation); - } - } - - pub fn walk_ts_function_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSFunctionType<'a>) { - if let Some(parameters) = &ty.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - if let Some(this_param) = &ty.this_param { - visitor.visit_ts_this_parameter(this_param); - } - visitor.visit_formal_parameters(&ty.params); - visitor.visit_ts_type_annotation(&ty.return_type); - } - - pub fn walk_ts_this_parameter<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSThisParameter<'a>) { - let kind = AstKind::TSThisParameter(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.visit_identifier_name(&ty.this); - if let Some(type_annotation) = &ty.type_annotation { - visitor.visit_ts_type_annotation(type_annotation); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_type_parameter<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSTypeParameter<'a>) { - let kind = AstKind::TSTypeParameter(visitor.alloc(ty)); - visitor.enter_scope(ScopeFlags::empty()); - visitor.enter_node(kind); - if let Some(constraint) = &ty.constraint { - visitor.visit_ts_type(constraint); - } - - if let Some(default) = &ty.default { - visitor.visit_ts_type(default); - } - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_ts_type_parameter_instantiation<'a, V: Visit<'a>>( - visitor: &mut V, - ty: &TSTypeParameterInstantiation<'a>, - ) { - let kind = AstKind::TSTypeParameterInstantiation(visitor.alloc(ty)); - visitor.enter_node(kind); - for ts_parameter in &ty.params { - visitor.visit_ts_type(ts_parameter); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_type_parameter_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - ty: &TSTypeParameterDeclaration<'a>, - ) { - let kind = AstKind::TSTypeParameterDeclaration(visitor.alloc(ty)); - visitor.enter_node(kind); - for ts_parameter in &ty.params { - visitor.visit_ts_type_parameter(ts_parameter); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_constructor_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSConstructorType<'a>) { - visitor.visit_formal_parameters(&ty.params); - if let Some(parameters) = &ty.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - visitor.visit_ts_type_annotation(&ty.return_type); - } - - pub fn walk_ts_conditional_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSConditionalType<'a>) { - visitor.visit_ts_type(&ty.check_type); - visitor.visit_ts_type(&ty.extends_type); - visitor.visit_ts_type(&ty.true_type); - visitor.visit_ts_type(&ty.false_type); - } - - pub fn walk_ts_array_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSArrayType<'a>) { - visitor.visit_ts_type(&ty.element_type); - } - - pub fn walk_ts_null_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSNullKeyword) { - let kind = AstKind::TSNullKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_any_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSAnyKeyword) { - let kind = AstKind::TSAnyKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_void_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSVoidKeyword) { - let kind = AstKind::TSVoidKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_intersection_type<'a, V: Visit<'a>>( - visitor: &mut V, - ty: &TSIntersectionType<'a>, - ) { - let kind = AstKind::TSIntersectionType(visitor.alloc(ty)); - visitor.enter_node(kind); - for ty in &ty.types { - visitor.visit_ts_type(ty); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_type_reference<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSTypeReference<'a>) { - let kind = AstKind::TSTypeReference(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.visit_ts_type_name(&ty.type_name); - if let Some(parameters) = &ty.type_parameters { - visitor.visit_ts_type_parameter_instantiation(parameters); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_union_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSUnionType<'a>) { - let kind = AstKind::TSUnionType(visitor.alloc(ty)); - visitor.enter_node(kind); - for ty in &ty.types { - visitor.visit_ts_type(ty); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_literal_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSLiteralType<'a>) { - let kind = AstKind::TSLiteralType(visitor.alloc(ty)); - visitor.enter_node(kind); - match &ty.literal { - TSLiteral::BigIntLiteral(lit) => visitor.visit_bigint_literal(lit), - TSLiteral::BooleanLiteral(lit) => visitor.visit_boolean_literal(lit), - TSLiteral::NullLiteral(lit) => visitor.visit_null_literal(lit), - TSLiteral::NumericLiteral(lit) => visitor.visit_number_literal(lit), - TSLiteral::RegExpLiteral(lit) => visitor.visit_reg_expr_literal(lit), - TSLiteral::StringLiteral(lit) => visitor.visit_string_literal(lit), - TSLiteral::TemplateLiteral(lit) => visitor.visit_template_literal(lit), - TSLiteral::UnaryExpression(expr) => visitor.visit_unary_expression(expr), - } - visitor.leave_node(kind); - } - - pub fn walk_ts_signature<'a, V: Visit<'a>>(visitor: &mut V, signature: &TSSignature<'a>) { - match &signature { - TSSignature::TSPropertySignature(sig) => visitor.visit_ts_property_signature(sig), - TSSignature::TSCallSignatureDeclaration(sig) => { - visitor.visit_ts_call_signature_declaration(sig); - } - TSSignature::TSIndexSignature(sig) => visitor.visit_ts_index_signature(sig), - TSSignature::TSMethodSignature(sig) => visitor.visit_ts_method_signature(sig), - TSSignature::TSConstructSignatureDeclaration(sig) => { - visitor.visit_ts_construct_signature_declaration(sig); - } - } - } - - pub fn walk_ts_construct_signature_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - signature: &TSConstructSignatureDeclaration<'a>, - ) { - visitor.visit_formal_parameters(&signature.params); - if let Some(parameters) = &signature.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - if let Some(annotation) = &signature.return_type { - visitor.visit_ts_type_annotation(annotation); - } - } - - pub fn walk_ts_method_signature<'a, V: Visit<'a>>( - visitor: &mut V, - signature: &TSMethodSignature<'a>, - ) { - let kind = AstKind::TSMethodSignature(visitor.alloc(signature)); - visitor.enter_node(kind); - visitor.visit_formal_parameters(&signature.params); - if let Some(parameters) = &signature.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - if let Some(annotation) = &signature.return_type { - visitor.visit_ts_type_annotation(annotation); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_index_signature_name<'a, V: Visit<'a>>( - visitor: &mut V, - name: &TSIndexSignatureName<'a>, - ) { - visitor.visit_ts_type_annotation(&name.type_annotation); - } - - pub fn walk_ts_index_signature<'a, V: Visit<'a>>( - visitor: &mut V, - signature: &TSIndexSignature<'a>, - ) { - for name in &signature.parameters { - visitor.visit_ts_index_signature_name(name); - } - - visitor.visit_ts_type_annotation(&signature.type_annotation); - } - - pub fn walk_ts_property_signature<'a, V: Visit<'a>>( - visitor: &mut V, - signature: &TSPropertySignature<'a>, - ) { - let kind = AstKind::TSPropertySignature(visitor.alloc(signature)); - visitor.enter_node(kind); - visitor.visit_property_key(&signature.key); - if let Some(annotation) = &signature.type_annotation { - visitor.visit_ts_type_annotation(annotation); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_call_signature_declaration<'a, V: Visit<'a>>( - visitor: &mut V, - signature: &TSCallSignatureDeclaration<'a>, - ) { - visitor.visit_formal_parameters(&signature.params); - if let Some(parameters) = &signature.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - - if let Some(annotation) = &signature.return_type { - visitor.visit_ts_type_annotation(annotation); - } - } - - pub fn walk_ts_type_query<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSTypeQuery<'a>) { - let kind = AstKind::TSTypeQuery(visitor.alloc(ty)); - visitor.enter_node(kind); - match &ty.expr_name { - name @ match_ts_type_name!(TSTypeQueryExprName) => { - visitor.visit_ts_type_name(name.to_ts_type_name()); - } - TSTypeQueryExprName::TSImportType(import) => visitor.visit_ts_import_type(import), - } - if let Some(type_parameters) = &ty.type_parameters { - visitor.visit_ts_type_parameter_instantiation(type_parameters); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_import_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSImportType<'a>) { - let kind = AstKind::TSImportType(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.visit_ts_type(&ty.parameter); - if let Some(name) = &ty.qualifier { - visitor.visit_ts_type_name(name); - } - if let Some(attrs) = &ty.attributes { - visitor.visit_ts_import_attributes(attrs); - } - if let Some(type_parameter) = &ty.type_parameters { - visitor.visit_ts_type_parameter_instantiation(type_parameter); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_import_attributes<'a, V: Visit<'a>>( - visitor: &mut V, - attributes: &TSImportAttributes<'a>, - ) { - for element in &attributes.elements { - visitor.visit_ts_import_attribute(element); - } - } - - pub fn walk_ts_import_attribute<'a, V: Visit<'a>>( - visitor: &mut V, - attribute: &TSImportAttribute<'a>, - ) { - visitor.visit_ts_import_attribute_name(&attribute.name); - visitor.visit_expression(&attribute.value); - } - - pub fn walk_ts_import_attribute_name<'a, V: Visit<'a>>( - visitor: &mut V, - name: &TSImportAttributeName<'a>, - ) { - match name { - TSImportAttributeName::Identifier(ident) => visitor.visit_identifier_name(ident), - TSImportAttributeName::StringLiteral(ident) => visitor.visit_string_literal(ident), - } - } - - pub fn walk_ts_big_int_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSBigIntKeyword) { - let kind = AstKind::TSBigIntKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_boolean_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSBooleanKeyword) { - let kind = AstKind::TSBooleanKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_intrinsic_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSIntrinsicKeyword) { - let kind = AstKind::TSIntrinsicKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_never_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSNeverKeyword) { - let kind = AstKind::TSNeverKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_number_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSNumberKeyword) { - let kind = AstKind::TSNumberKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_object_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSObjectKeyword) { - let kind = AstKind::TSObjectKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_string_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSStringKeyword) { - let kind = AstKind::TSStringKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_symbol_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSSymbolKeyword) { - let kind = AstKind::TSSymbolKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_this_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSThisType) { - let kind = AstKind::TSThisType(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_undefined_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSUndefinedKeyword) { - let kind = AstKind::TSUndefinedKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_unknown_keyword<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSUnknownKeyword) { - let kind = AstKind::TSUnknownKeyword(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_infer_type<'a, V: Visit<'a>>(visitor: &mut V, ty: &TSInferType<'a>) { - let kind = AstKind::TSInferType(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.visit_ts_type_parameter(&ty.type_parameter); - visitor.leave_node(kind); - } - - pub fn walk_ts_named_tuple_member<'a, V: Visit<'a>>( - visitor: &mut V, - ty: &TSNamedTupleMember<'a>, - ) { - let kind = AstKind::TSNamedTupleMember(visitor.alloc(ty)); - visitor.enter_node(kind); - visitor.visit_identifier_name(&ty.label); - visitor.visit_ts_tuple_element(&ty.element_type); - visitor.leave_node(kind); - } - - pub fn walk_ts_template_literal_type<'a, V: Visit<'a>>( - visitor: &mut V, - ty: &TSTemplateLiteralType<'a>, - ) { - let kind = AstKind::TSTemplateLiteralType(visitor.alloc(ty)); - visitor.enter_node(kind); - for quasi in &ty.quasis { - visitor.visit_template_element(quasi); - } - for ty in &ty.types { - visitor.visit_ts_type(ty); - } - visitor.leave_node(kind); - } -} diff --git a/crates/oxc_ast/src/visit/visit_mut.rs b/crates/oxc_ast/src/visit/visit_mut.rs deleted file mode 100644 index de7e72730ba4..000000000000 --- a/crates/oxc_ast/src/visit/visit_mut.rs +++ /dev/null @@ -1,3244 +0,0 @@ -//! Visit Mut Pattern - -use oxc_allocator::Vec; -use oxc_syntax::scope::ScopeFlags; - -#[allow(clippy::wildcard_imports)] -use self::walk_mut::*; -use crate::{ast::*, AstType}; - -/// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in place. -pub trait VisitMut<'a>: Sized { - #[allow(unused_variables)] - fn enter_node(&mut self, kind: AstType) {} - #[allow(unused_variables)] - fn leave_node(&mut self, kind: AstType) {} - - #[allow(unused_variables)] - fn enter_scope(&mut self, flags: ScopeFlags) {} - fn leave_scope(&mut self) {} - - fn visit_program(&mut self, program: &mut Program<'a>) { - walk_program_mut(self, program); - } - - /* ---------- Statement ---------- */ - - fn visit_statements(&mut self, stmts: &mut Vec<'a, Statement<'a>>) { - walk_statements_mut(self, stmts); - } - - fn visit_statement(&mut self, stmt: &mut Statement<'a>) { - walk_statement_mut(self, stmt); - } - - fn visit_block_statement(&mut self, stmt: &mut BlockStatement<'a>) { - walk_block_statement_mut(self, stmt); - } - - fn visit_break_statement(&mut self, stmt: &mut BreakStatement<'a>) { - walk_break_statement_mut(self, stmt); - } - - fn visit_continue_statement(&mut self, stmt: &mut ContinueStatement<'a>) { - walk_continue_statement_mut(self, stmt); - } - - fn visit_debugger_statement(&mut self, stmt: &mut DebuggerStatement) { - walk_debugger_statement_mut(self, stmt); - } - - fn visit_do_while_statement(&mut self, stmt: &mut DoWhileStatement<'a>) { - walk_do_while_statement_mut(self, stmt); - } - - fn visit_empty_statement(&mut self, stmt: &mut EmptyStatement) { - walk_empty_statement_mut(self, stmt); - } - - fn visit_expression_statement(&mut self, stmt: &mut ExpressionStatement<'a>) { - walk_expression_statement_mut(self, stmt); - } - - fn visit_for_statement(&mut self, stmt: &mut ForStatement<'a>) { - walk_for_statement_mut(self, stmt); - } - - fn visit_for_statement_init(&mut self, init: &mut ForStatementInit<'a>) { - walk_for_statement_init_mut(self, init); - } - - fn visit_for_in_statement(&mut self, stmt: &mut ForInStatement<'a>) { - walk_for_in_statement_mut(self, stmt); - } - - fn visit_for_of_statement(&mut self, stmt: &mut ForOfStatement<'a>) { - walk_for_of_statement_mut(self, stmt); - } - - fn visit_for_statement_left(&mut self, left: &mut ForStatementLeft<'a>) { - walk_for_statement_left_mut(self, left); - } - - fn visit_if_statement(&mut self, stmt: &mut IfStatement<'a>) { - walk_if_statement_mut(self, stmt); - } - - fn visit_labeled_statement(&mut self, stmt: &mut LabeledStatement<'a>) { - walk_labeled_statement_mut(self, stmt); - } - - fn visit_return_statement(&mut self, stmt: &mut ReturnStatement<'a>) { - walk_return_statement_mut(self, stmt); - } - - fn visit_switch_statement(&mut self, stmt: &mut SwitchStatement<'a>) { - walk_switch_statement_mut(self, stmt); - } - - fn visit_switch_case(&mut self, case: &mut SwitchCase<'a>) { - walk_switch_case_mut(self, case); - } - - fn visit_throw_statement(&mut self, stmt: &mut ThrowStatement<'a>) { - walk_throw_statement_mut(self, stmt); - } - - fn visit_try_statement(&mut self, stmt: &mut TryStatement<'a>) { - walk_try_statement_mut(self, stmt); - } - - fn visit_catch_clause(&mut self, clause: &mut CatchClause<'a>) { - walk_catch_clause_mut(self, clause); - } - - fn visit_catch_parameter(&mut self, param: &mut CatchParameter<'a>) { - walk_catch_parameter_mut(self, param); - } - - fn visit_finally_clause(&mut self, clause: &mut BlockStatement<'a>) { - walk_finally_clause_mut(self, clause); - } - - fn visit_while_statement(&mut self, stmt: &mut WhileStatement<'a>) { - walk_while_statement_mut(self, stmt); - } - - fn visit_with_statement(&mut self, stmt: &mut WithStatement<'a>) { - walk_with_statement_mut(self, stmt); - } - - fn visit_directive(&mut self, directive: &mut Directive<'a>) { - walk_directive_mut(self, directive); - } - - /* ---------- Declaration ---------- */ - - fn visit_variable_declaration(&mut self, decl: &mut VariableDeclaration<'a>) { - walk_variable_declaration_mut(self, decl); - } - - fn visit_variable_declarator(&mut self, declarator: &mut VariableDeclarator<'a>) { - walk_variable_declarator_mut(self, declarator); - } - - fn visit_using_declaration(&mut self, declaration: &mut UsingDeclaration<'a>) { - walk_using_declaration_mut(self, declaration); - } - - /* ---------- Function ---------- */ - - fn visit_function(&mut self, func: &mut Function<'a>, flags: Option) { - walk_function_mut(self, func, flags); - } - - fn visit_function_body(&mut self, body: &mut FunctionBody<'a>) { - walk_function_body_mut(self, body); - } - - fn visit_formal_parameters(&mut self, params: &mut FormalParameters<'a>) { - walk_formal_parameters_mut(self, params); - } - - fn visit_formal_parameter(&mut self, param: &mut FormalParameter<'a>) { - walk_formal_parameter_mut(self, param); - } - - /* ---------- Class ---------- */ - - fn visit_decorator(&mut self, decorator: &mut Decorator<'a>) { - walk_decorator_mut(self, decorator); - } - - fn visit_class(&mut self, class: &mut Class<'a>) { - walk_class_mut(self, class); - } - - fn visit_class_heritage(&mut self, expr: &mut Expression<'a>) { - walk_class_heritage_mut(self, expr); - } - - fn visit_class_body(&mut self, body: &mut ClassBody<'a>) { - walk_class_body_mut(self, body); - } - - fn visit_class_element(&mut self, elem: &mut ClassElement<'a>) { - walk_class_element_mut(self, elem); - } - - fn visit_static_block(&mut self, block: &mut StaticBlock<'a>) { - walk_static_block_mut(self, block); - } - - fn visit_method_definition(&mut self, def: &mut MethodDefinition<'a>) { - walk_method_definition_mut(self, def); - } - - fn visit_property_definition(&mut self, def: &mut PropertyDefinition<'a>) { - walk_property_definition_mut(self, def); - } - - /* ---------- Expression ---------- */ - - fn visit_expression(&mut self, expr: &mut Expression<'a>) { - walk_expression_mut(self, expr); - } - - fn visit_meta_property(&mut self, meta: &mut MetaProperty<'a>) { - walk_meta_property_mut(self, meta); - } - - fn visit_array_expression(&mut self, expr: &mut ArrayExpression<'a>) { - walk_array_expression_mut(self, expr); - } - - fn visit_array_expression_element(&mut self, arg: &mut ArrayExpressionElement<'a>) { - walk_array_expression_element_mut(self, arg); - } - - fn visit_argument(&mut self, arg: &mut Argument<'a>) { - walk_argument_mut(self, arg); - } - - fn visit_spread_element(&mut self, elem: &mut SpreadElement<'a>) { - walk_spread_element_mut(self, elem); - } - - fn visit_expression_array_element(&mut self, expr: &mut Expression<'a>) { - walk_expression_array_element_mut(self, expr); - } - - fn visit_elision(&mut self, elision: &mut Elision) { - walk_elision_mut(self, elision); - } - - fn visit_assignment_expression(&mut self, expr: &mut AssignmentExpression<'a>) { - walk_assignment_expression_mut(self, expr); - } - - fn visit_arrow_expression(&mut self, expr: &mut ArrowFunctionExpression<'a>) { - walk_arrow_expression_mut(self, expr); - } - - fn visit_await_expression(&mut self, expr: &mut AwaitExpression<'a>) { - walk_await_expression_mut(self, expr); - } - - fn visit_binary_expression(&mut self, expr: &mut BinaryExpression<'a>) { - walk_binary_expression_mut(self, expr); - } - - fn visit_call_expression(&mut self, expr: &mut CallExpression<'a>) { - walk_call_expression_mut(self, expr); - } - - fn visit_chain_expression(&mut self, expr: &mut ChainExpression<'a>) { - walk_chain_expression_mut(self, expr); - } - - fn visit_chain_element(&mut self, elem: &mut ChainElement<'a>) { - walk_chain_element_mut(self, elem); - } - - fn visit_conditional_expression(&mut self, expr: &mut ConditionalExpression<'a>) { - walk_conditional_expression_mut(self, expr); - } - - fn visit_import_expression(&mut self, expr: &mut ImportExpression<'a>) { - walk_import_expression_mut(self, expr); - } - - fn visit_logical_expression(&mut self, expr: &mut LogicalExpression<'a>) { - walk_logical_expression_mut(self, expr); - } - - fn visit_member_expression(&mut self, expr: &mut MemberExpression<'a>) { - walk_member_expression_mut(self, expr); - } - - fn visit_computed_member_expression(&mut self, expr: &mut ComputedMemberExpression<'a>) { - walk_computed_member_expression_mut(self, expr); - } - - fn visit_static_member_expression(&mut self, expr: &mut StaticMemberExpression<'a>) { - walk_static_member_expression_mut(self, expr); - } - - fn visit_private_field_expression(&mut self, expr: &mut PrivateFieldExpression<'a>) { - walk_private_field_expression_mut(self, expr); - } - - fn visit_new_expression(&mut self, expr: &mut NewExpression<'a>) { - walk_new_expression_mut(self, expr); - } - - fn visit_object_expression(&mut self, expr: &mut ObjectExpression<'a>) { - walk_object_expression_mut(self, expr); - } - - fn visit_object_property_kind(&mut self, prop: &mut ObjectPropertyKind<'a>) { - walk_object_property_kind_mut(self, prop); - } - - fn visit_object_property(&mut self, prop: &mut ObjectProperty<'a>) { - walk_object_property_mut(self, prop); - } - - fn visit_property_key(&mut self, key: &mut PropertyKey<'a>) { - walk_property_key_mut(self, key); - } - - fn visit_parenthesized_expression(&mut self, expr: &mut ParenthesizedExpression<'a>) { - walk_parenthesized_expression_mut(self, expr); - } - - fn visit_private_in_expression(&mut self, expr: &mut PrivateInExpression<'a>) { - walk_private_in_expression_mut(self, expr); - } - - fn visit_sequence_expression(&mut self, expr: &mut SequenceExpression<'a>) { - walk_sequence_expression_mut(self, expr); - } - - fn visit_tagged_template_expression(&mut self, expr: &mut TaggedTemplateExpression<'a>) { - walk_tagged_template_expression_mut(self, expr); - } - - fn visit_this_expression(&mut self, expr: &mut ThisExpression) { - walk_this_expression_mut(self, expr); - } - - fn visit_unary_expression(&mut self, expr: &mut UnaryExpression<'a>) { - walk_unary_expression_mut(self, expr); - } - - fn visit_update_expression(&mut self, expr: &mut UpdateExpression<'a>) { - walk_update_expression_mut(self, expr); - } - - fn visit_yield_expression(&mut self, expr: &mut YieldExpression<'a>) { - walk_yield_expression_mut(self, expr); - } - - fn visit_super(&mut self, expr: &mut Super) { - walk_super_mut(self, expr); - } - - fn visit_assignment_target(&mut self, target: &mut AssignmentTarget<'a>) { - walk_assignment_target_mut(self, target); - } - - fn visit_simple_assignment_target(&mut self, target: &mut SimpleAssignmentTarget<'a>) { - walk_simple_assignment_target_mut(self, target); - } - - fn visit_assignment_target_pattern(&mut self, pat: &mut AssignmentTargetPattern<'a>) { - walk_assignment_target_pattern_mut(self, pat); - } - - fn visit_array_assignment_target(&mut self, target: &mut ArrayAssignmentTarget<'a>) { - walk_array_assignment_target_mut(self, target); - } - - fn visit_assignment_target_maybe_default( - &mut self, - target: &mut AssignmentTargetMaybeDefault<'a>, - ) { - walk_assignment_target_maybe_default_mut(self, target); - } - - fn visit_assignment_target_with_default( - &mut self, - target: &mut AssignmentTargetWithDefault<'a>, - ) { - walk_assignment_target_with_default_mut(self, target); - } - - fn visit_object_assignment_target(&mut self, target: &mut ObjectAssignmentTarget<'a>) { - walk_object_assignment_target_mut(self, target); - } - - fn visit_assignment_target_property(&mut self, property: &mut AssignmentTargetProperty<'a>) { - walk_assignment_target_property_mut(self, property); - } - - fn visit_assignment_target_property_identifier( - &mut self, - ident: &mut AssignmentTargetPropertyIdentifier<'a>, - ) { - walk_assignment_target_property_identifier_mut(self, ident); - } - - fn visit_assignment_target_property_property( - &mut self, - property: &mut AssignmentTargetPropertyProperty<'a>, - ) { - walk_assignment_target_property_property_mut(self, property); - } - - fn visit_assignment_target_rest(&mut self, rest: &mut AssignmentTargetRest<'a>) { - walk_assignment_target_rest_mut(self, rest); - } - - /* ---------- Expression ---------- */ - - fn visit_jsx_element(&mut self, elem: &mut JSXElement<'a>) { - walk_jsx_element_mut(self, elem); - } - - fn visit_jsx_opening_element(&mut self, elem: &mut JSXOpeningElement<'a>) { - walk_jsx_opening_element_mut(self, elem); - } - - fn visit_jsx_closing_element(&mut self, elem: &mut JSXClosingElement<'a>) { - walk_jsx_closing_element_mut(self, elem); - } - - fn visit_jsx_element_name(&mut self, name: &mut JSXElementName<'a>) { - walk_jsx_element_name_mut(self, name); - } - - fn visit_jsx_identifier(&mut self, ident: &mut JSXIdentifier<'a>) { - walk_jsx_identifier_mut(self, ident); - } - - fn visit_jsx_member_expression(&mut self, expr: &mut JSXMemberExpression<'a>) { - walk_jsx_member_expression_mut(self, expr); - } - - fn visit_jsx_member_expression_object(&mut self, expr: &mut JSXMemberExpressionObject<'a>) { - walk_jsx_member_expression_object_mut(self, expr); - } - - fn visit_jsx_namespaced_name(&mut self, name: &mut JSXNamespacedName<'a>) { - walk_jsx_namespaced_name_mut(self, name); - } - - fn visit_jsx_attribute_item(&mut self, item: &mut JSXAttributeItem<'a>) { - walk_jsx_attribute_item_mut(self, item); - } - - fn visit_jsx_attribute(&mut self, attribute: &mut JSXAttribute<'a>) { - walk_jsx_attribute_mut(self, attribute); - } - - fn visit_jsx_spread_attribute(&mut self, attribute: &mut JSXSpreadAttribute<'a>) { - walk_jsx_spread_attribute_mut(self, attribute); - } - - fn visit_jsx_attribute_value(&mut self, value: &mut JSXAttributeValue<'a>) { - walk_jsx_attribute_value_mut(self, value); - } - - fn visit_jsx_expression_container(&mut self, expr: &mut JSXExpressionContainer<'a>) { - walk_jsx_expression_container_mut(self, expr); - } - - fn visit_jsx_expression(&mut self, expr: &mut JSXExpression<'a>) { - walk_jsx_expression_mut(self, expr); - } - - fn visit_jsx_fragment(&mut self, elem: &mut JSXFragment<'a>) { - walk_jsx_fragment_mut(self, elem); - } - - fn visit_jsx_child(&mut self, child: &mut JSXChild<'a>) { - walk_jsx_child_mut(self, child); - } - - fn visit_jsx_spread_child(&mut self, child: &mut JSXSpreadChild<'a>) { - walk_jsx_spread_child_mut(self, child); - } - - fn visit_jsx_text(&mut self, child: &JSXText<'a>) { - walk_jsx_text_mut(self, child); - } - - /* ---------- Pattern ---------- */ - - fn visit_binding_pattern(&mut self, pat: &mut BindingPattern<'a>) { - walk_binding_pattern_mut(self, pat); - } - - fn visit_binding_identifier(&mut self, ident: &mut BindingIdentifier<'a>) { - walk_binding_identifier_mut(self, ident); - } - - fn visit_object_pattern(&mut self, pat: &mut ObjectPattern<'a>) { - walk_object_pattern_mut(self, pat); - } - - fn visit_binding_property(&mut self, prop: &mut BindingProperty<'a>) { - walk_binding_property_mut(self, prop); - } - - fn visit_array_pattern(&mut self, pat: &mut ArrayPattern<'a>) { - walk_array_pattern_mut(self, pat); - } - - fn visit_rest_element(&mut self, pat: &mut BindingRestElement<'a>) { - walk_rest_element_mut(self, pat); - } - - fn visit_assignment_pattern(&mut self, pat: &mut AssignmentPattern<'a>) { - walk_assignment_pattern_mut(self, pat); - } - - /* ---------- Identifier ---------- */ - - fn visit_identifier_reference(&mut self, ident: &mut IdentifierReference<'a>) { - walk_identifier_reference_mut(self, ident); - } - - fn visit_private_identifier(&mut self, ident: &mut PrivateIdentifier<'a>) { - walk_private_identifier_mut(self, ident); - } - - fn visit_label_identifier(&mut self, ident: &mut LabelIdentifier<'a>) { - walk_label_identifier_mut(self, ident); - } - - fn visit_identifier_name(&mut self, ident: &mut IdentifierName<'a>) { - walk_identifier_name_mut(self, ident); - } - - /* ---------- Literal ---------- */ - - fn visit_number_literal(&mut self, lit: &mut NumericLiteral<'a>) { - walk_number_literal_mut(self, lit); - } - - fn visit_boolean_literal(&mut self, lit: &mut BooleanLiteral) { - walk_boolean_literal_mut(self, lit); - } - - fn visit_null_literal(&mut self, lit: &mut NullLiteral) { - walk_null_literal_mut(self, lit); - } - - fn visit_bigint_literal(&mut self, lit: &mut BigIntLiteral<'a>) { - walk_bigint_literal_mut(self, lit); - } - - fn visit_string_literal(&mut self, lit: &mut StringLiteral<'a>) { - walk_string_literal_mut(self, lit); - } - - fn visit_template_literal(&mut self, lit: &mut TemplateLiteral<'a>) { - walk_template_literal_mut(self, lit); - } - - fn visit_reg_expr_literal(&mut self, lit: &mut RegExpLiteral<'a>) { - walk_reg_expr_literal_mut(self, lit); - } - - fn visit_template_element(&mut self, _elem: &mut TemplateElement) {} - - /* ---------- Module ---------- */ - - fn visit_module_declaration(&mut self, decl: &mut ModuleDeclaration<'a>) { - walk_module_declaration_mut(self, decl); - } - - fn visit_import_declaration(&mut self, decl: &mut ImportDeclaration<'a>) { - walk_import_declaration_mut(self, decl); - } - - fn visit_with_clause(&mut self, with_clause: &mut WithClause<'a>) { - walk_with_clause_mut(self, with_clause); - } - - fn visit_import_attribute(&mut self, attribute: &mut ImportAttribute<'a>) { - walk_import_attribute_mut(self, attribute); - } - - fn visit_import_attribute_key(&mut self, key: &mut ImportAttributeKey<'a>) { - walk_import_attribute_key_mut(self, key); - } - - fn visit_import_declaration_specifier( - &mut self, - specifier: &mut ImportDeclarationSpecifier<'a>, - ) { - walk_import_declaration_specifier_mut(self, specifier); - } - - fn visit_import_specifier(&mut self, specifier: &mut ImportSpecifier<'a>) { - walk_import_specifier_mut(self, specifier); - } - - fn visit_import_default_specifier(&mut self, specifier: &mut ImportDefaultSpecifier<'a>) { - walk_import_default_specifier_mut(self, specifier); - } - - fn visit_import_name_specifier(&mut self, specifier: &mut ImportNamespaceSpecifier<'a>) { - walk_import_name_specifier_mut(self, specifier); - } - - fn visit_export_all_declaration(&mut self, decl: &mut ExportAllDeclaration<'a>) { - walk_export_all_declaration_mut(self, decl); - } - - fn visit_export_default_declaration(&mut self, decl: &mut ExportDefaultDeclaration<'a>) { - walk_export_default_declaration_mut(self, decl); - } - - fn visit_export_named_declaration(&mut self, decl: &mut ExportNamedDeclaration<'a>) { - walk_export_named_declaration_mut(self, decl); - } - - fn visit_enum_member(&mut self, member: &mut TSEnumMember<'a>) { - walk_enum_member_mut(self, member); - } - - fn visit_enum(&mut self, decl: &mut TSEnumDeclaration<'a>) { - walk_enum_mut(self, decl); - } - - fn visit_declaration(&mut self, decl: &mut Declaration<'a>) { - walk_declaration_mut(self, decl); - } - - /* ---------- TypeScript ---------- */ - - fn visit_ts_import_equals_declaration(&mut self, decl: &mut TSImportEqualsDeclaration<'a>) { - walk_ts_import_equals_declaration_mut(self, decl); - } - - fn visit_ts_module_reference(&mut self, reference: &mut TSModuleReference<'a>) { - walk_ts_module_reference_mut(self, reference); - } - - fn visit_ts_type_name(&mut self, name: &mut TSTypeName<'a>) { - walk_ts_type_name_mut(self, name); - } - - fn visit_ts_external_module_reference( - &mut self, - reference: &mut TSExternalModuleReference<'a>, - ) { - walk_ts_external_module_reference_mut(self, reference); - } - - fn visit_ts_qualified_name(&mut self, name: &mut TSQualifiedName<'a>) { - walk_ts_qualified_name_mut(self, name); - } - - fn visit_ts_module_declaration(&mut self, decl: &mut TSModuleDeclaration<'a>) { - walk_ts_module_declaration_mut(self, decl); - } - - fn visit_ts_module_block(&mut self, block: &mut TSModuleBlock<'a>) { - walk_ts_module_block_mut(self, block); - } - - fn visit_ts_type_alias_declaration(&mut self, decl: &mut TSTypeAliasDeclaration<'a>) { - walk_ts_type_alias_declaration_mut(self, decl); - } - - fn visit_ts_interface_declaration(&mut self, decl: &mut TSInterfaceDeclaration<'a>) { - walk_ts_interface_declaration_mut(self, decl); - } - - fn visit_ts_as_expression(&mut self, expr: &mut TSAsExpression<'a>) { - walk_ts_as_expression_mut(self, expr); - } - - fn visit_ts_satisfies_expression(&mut self, expr: &mut TSSatisfiesExpression<'a>) { - walk_ts_satisfies_expression_mut(self, expr); - } - - fn visit_ts_non_null_expression(&mut self, expr: &mut TSNonNullExpression<'a>) { - walk_ts_non_null_expression_mut(self, expr); - } - - fn visit_ts_type_assertion(&mut self, expr: &mut TSTypeAssertion<'a>) { - walk_ts_type_assertion_mut(self, expr); - } - - fn visit_ts_instantiation_expression(&mut self, expr: &mut TSInstantiationExpression<'a>) { - walk_ts_instantiation_expression_mut(self, expr); - } - - fn visit_ts_type_annotation(&mut self, annotation: &mut TSTypeAnnotation<'a>) { - walk_ts_type_annotation_mut(self, annotation); - } - - fn visit_ts_type(&mut self, ty: &mut TSType<'a>) { - walk_ts_type_mut(self, ty); - } - - fn visit_ts_type_literal(&mut self, ty: &mut TSTypeLiteral<'a>) { - walk_ts_type_literal_mut(self, ty); - } - - fn visit_ts_indexed_access_type(&mut self, ty: &mut TSIndexedAccessType<'a>) { - walk_ts_indexed_access_type_mut(self, ty); - } - - fn visit_ts_type_predicate(&mut self, ty: &mut TSTypePredicate<'a>) { - walk_ts_type_predicate_mut(self, ty); - } - - fn visit_ts_type_operator_type(&mut self, ty: &mut TSTypeOperator<'a>) { - walk_ts_type_operator_type_mut(self, ty); - } - - fn visit_ts_tuple_type(&mut self, ty: &mut TSTupleType<'a>) { - walk_ts_tuple_type_mut(self, ty); - } - - fn visit_ts_tuple_element(&mut self, ty: &mut TSTupleElement<'a>) { - walk_ts_tuple_element_mut(self, ty); - } - - fn visit_ts_mapped_type(&mut self, ty: &mut TSMappedType<'a>) { - walk_ts_mapped_type_mut(self, ty); - } - - fn visit_ts_function_type(&mut self, ty: &mut TSFunctionType<'a>) { - walk_ts_function_type_mut(self, ty); - } - - fn visit_ts_type_parameter(&mut self, ty: &mut TSTypeParameter<'a>) { - walk_ts_type_parameter_mut(self, ty); - } - - fn visit_ts_type_parameter_instantiation(&mut self, ty: &mut TSTypeParameterInstantiation<'a>) { - walk_ts_type_parameter_instantiation_mut(self, ty); - } - - fn visit_ts_type_parameter_declaration(&mut self, ty: &mut TSTypeParameterDeclaration<'a>) { - walk_ts_type_parameter_declaration_mut(self, ty); - } - - fn visit_ts_constructor_type(&mut self, ty: &mut TSConstructorType<'a>) { - walk_ts_constructor_type_mut(self, ty); - } - - fn visit_ts_conditional_type(&mut self, ty: &mut TSConditionalType<'a>) { - walk_ts_conditional_type_mut(self, ty); - } - - fn visit_ts_array_type(&mut self, ty: &mut TSArrayType<'a>) { - walk_ts_array_type_mut(self, ty); - } - - fn visit_ts_null_keyword(&mut self, ty: &mut TSNullKeyword) { - walk_ts_null_keyword_mut(self, ty); - } - - fn visit_ts_any_keyword(&mut self, ty: &mut TSAnyKeyword) { - walk_ts_any_keyword_mut(self, ty); - } - - fn visit_ts_void_keyword(&mut self, ty: &mut TSVoidKeyword) { - walk_ts_void_keyword_mut(self, ty); - } - - fn visit_ts_intersection_type(&mut self, ty: &mut TSIntersectionType<'a>) { - walk_ts_intersection_type_mut(self, ty); - } - - fn visit_ts_type_reference(&mut self, ty: &mut TSTypeReference<'a>) { - walk_ts_type_reference_mut(self, ty); - } - - fn visit_ts_union_type(&mut self, ty: &mut TSUnionType<'a>) { - walk_ts_union_type_mut(self, ty); - } - - fn visit_ts_literal_type(&mut self, ty: &mut TSLiteralType<'a>) { - walk_ts_literal_type_mut(self, ty); - } - - fn visit_ts_signature(&mut self, signature: &mut TSSignature<'a>) { - walk_ts_signature_mut(self, signature); - } - - fn visit_ts_construct_signature_declaration( - &mut self, - signature: &mut TSConstructSignatureDeclaration<'a>, - ) { - walk_ts_construct_signature_declaration_mut(self, signature); - } - - fn visit_ts_method_signature(&mut self, signature: &mut TSMethodSignature<'a>) { - walk_ts_method_signature_mut(self, signature); - } - - fn visit_ts_index_signature_name(&mut self, name: &mut TSIndexSignatureName<'a>) { - walk_ts_index_signature_name_mut(self, name); - } - - fn visit_ts_index_signature(&mut self, signature: &mut TSIndexSignature<'a>) { - walk_ts_index_signature_mut(self, signature); - } - - fn visit_ts_property_signature(&mut self, signature: &mut TSPropertySignature<'a>) { - walk_ts_property_signature_mut(self, signature); - } - - fn visit_ts_call_signature_declaration( - &mut self, - signature: &mut TSCallSignatureDeclaration<'a>, - ) { - walk_ts_call_signature_declaration_mut(self, signature); - } - - fn visit_ts_type_query(&mut self, ty: &mut TSTypeQuery<'a>) { - walk_ts_type_query_mut(self, ty); - } - - fn visit_ts_import_type(&mut self, ty: &mut TSImportType<'a>) { - walk_ts_import_type_mut(self, ty); - } - - fn visit_ts_import_attributes(&mut self, attributes: &mut TSImportAttributes<'a>) { - walk_ts_import_attributes_mut(self, attributes); - } - - fn visit_ts_import_attribute(&mut self, attribute: &mut TSImportAttribute<'a>) { - walk_ts_import_attribute_mut(self, attribute); - } - - fn visit_ts_import_attribute_name(&mut self, name: &mut TSImportAttributeName<'a>) { - walk_ts_import_attribute_name_mut(self, name); - } -} - -pub mod walk_mut { - use super::*; - - pub fn walk_program_mut<'a, V: VisitMut<'a>>(visitor: &mut V, program: &mut Program<'a>) { - let kind = AstType::Program; - visitor.enter_scope({ - let mut flags = ScopeFlags::Top; - if program.is_strict() { - flags |= ScopeFlags::StrictMode; - } - flags - }); - visitor.enter_node(kind); - for directive in program.directives.iter_mut() { - visitor.visit_directive(directive); - } - visitor.visit_statements(&mut program.body); - - visitor.leave_node(kind); - visitor.leave_scope(); - } - - /* ---------- Statement ---------- */ - - pub fn walk_statements_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmts: &mut Vec<'a, Statement<'a>>, - ) { - for stmt in stmts.iter_mut() { - visitor.visit_statement(stmt); - } - } - - pub fn walk_statement_mut<'a, V: VisitMut<'a>>(visitor: &mut V, stmt: &mut Statement<'a>) { - match stmt { - Statement::BlockStatement(stmt) => visitor.visit_block_statement(stmt), - Statement::BreakStatement(stmt) => visitor.visit_break_statement(stmt), - Statement::ContinueStatement(stmt) => visitor.visit_continue_statement(stmt), - Statement::DebuggerStatement(stmt) => visitor.visit_debugger_statement(stmt), - Statement::DoWhileStatement(stmt) => visitor.visit_do_while_statement(stmt), - Statement::EmptyStatement(stmt) => visitor.visit_empty_statement(stmt), - Statement::ExpressionStatement(stmt) => visitor.visit_expression_statement(stmt), - Statement::ForInStatement(stmt) => visitor.visit_for_in_statement(stmt), - Statement::ForOfStatement(stmt) => visitor.visit_for_of_statement(stmt), - Statement::ForStatement(stmt) => visitor.visit_for_statement(stmt), - Statement::IfStatement(stmt) => visitor.visit_if_statement(stmt), - Statement::LabeledStatement(stmt) => visitor.visit_labeled_statement(stmt), - Statement::ReturnStatement(stmt) => visitor.visit_return_statement(stmt), - Statement::SwitchStatement(stmt) => visitor.visit_switch_statement(stmt), - Statement::ThrowStatement(stmt) => visitor.visit_throw_statement(stmt), - Statement::TryStatement(stmt) => visitor.visit_try_statement(stmt), - Statement::WhileStatement(stmt) => visitor.visit_while_statement(stmt), - Statement::WithStatement(stmt) => visitor.visit_with_statement(stmt), - - match_module_declaration!(Statement) => { - visitor.visit_module_declaration(stmt.to_module_declaration_mut()); - } - match_declaration!(Statement) => visitor.visit_declaration(stmt.to_declaration_mut()), - } - } - - pub fn walk_block_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut BlockStatement<'a>, - ) { - let kind = AstType::BlockStatement; - visitor.enter_scope(ScopeFlags::empty()); - visitor.enter_node(kind); - visitor.visit_statements(&mut stmt.body); - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_break_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut BreakStatement<'a>, - ) { - let kind = AstType::BreakStatement; - visitor.enter_node(kind); - if let Some(break_target) = &mut stmt.label { - visitor.visit_label_identifier(break_target); - } - visitor.leave_node(kind); - } - - pub fn walk_continue_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut ContinueStatement<'a>, - ) { - let kind = AstType::ContinueStatement; - visitor.enter_node(kind); - if let Some(continue_target) = &mut stmt.label { - visitor.visit_label_identifier(continue_target); - } - visitor.leave_node(kind); - } - - pub fn walk_debugger_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _stmt: &mut DebuggerStatement, - ) { - let kind = AstType::DebuggerStatement; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_do_while_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut DoWhileStatement<'a>, - ) { - let kind = AstType::DoWhileStatement; - visitor.enter_node(kind); - visitor.visit_statement(&mut stmt.body); - visitor.visit_expression(&mut stmt.test); - visitor.leave_node(kind); - } - - pub fn walk_empty_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _stmt: &mut EmptyStatement, - ) { - let kind = AstType::EmptyStatement; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_expression_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut ExpressionStatement<'a>, - ) { - let kind = AstType::ExpressionStatement; - visitor.enter_node(kind); - visitor.visit_expression(&mut stmt.expression); - visitor.leave_node(kind); - } - - pub fn walk_for_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut ForStatement<'a>, - ) { - let kind = AstType::ForStatement; - let is_lexical_declaration = - stmt.init.as_ref().is_some_and(ForStatementInit::is_lexical_declaration); - if is_lexical_declaration { - visitor.enter_scope(ScopeFlags::empty()); - } - visitor.enter_node(kind); - if let Some(init) = &mut stmt.init { - visitor.visit_for_statement_init(init); - } - if let Some(test) = &mut stmt.test { - visitor.visit_expression(test); - } - if let Some(update) = &mut stmt.update { - visitor.visit_expression(update); - } - visitor.visit_statement(&mut stmt.body); - visitor.leave_node(kind); - if is_lexical_declaration { - visitor.leave_scope(); - } - } - - pub fn walk_for_statement_init_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - init: &mut ForStatementInit<'a>, - ) { - let kind = AstType::ForStatementInit; - visitor.enter_node(kind); - match init { - ForStatementInit::VariableDeclaration(decl) => { - visitor.visit_variable_declaration(decl); - } - match_expression!(ForStatementInit) => { - visitor.visit_expression(init.to_expression_mut()); - } - ForStatementInit::UsingDeclaration(decl) => { - visitor.visit_using_declaration(decl); - } - } - visitor.leave_node(kind); - } - - pub fn walk_for_in_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut ForInStatement<'a>, - ) { - let kind = AstType::ForInStatement; - let is_lexical_declaration = stmt.left.is_lexical_declaration(); - if is_lexical_declaration { - visitor.enter_scope(ScopeFlags::empty()); - } - visitor.enter_node(kind); - visitor.visit_for_statement_left(&mut stmt.left); - visitor.visit_expression(&mut stmt.right); - visitor.visit_statement(&mut stmt.body); - visitor.leave_node(kind); - if is_lexical_declaration { - visitor.leave_scope(); - } - } - - pub fn walk_for_of_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut ForOfStatement<'a>, - ) { - let kind = AstType::ForOfStatement; - let is_lexical_declaration = stmt.left.is_lexical_declaration(); - if is_lexical_declaration { - visitor.enter_scope(ScopeFlags::empty()); - } - visitor.enter_node(kind); - visitor.visit_for_statement_left(&mut stmt.left); - visitor.visit_expression(&mut stmt.right); - visitor.visit_statement(&mut stmt.body); - visitor.leave_node(kind); - if is_lexical_declaration { - visitor.leave_scope(); - } - } - - pub fn walk_for_statement_left_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - left: &mut ForStatementLeft<'a>, - ) { - match left { - ForStatementLeft::VariableDeclaration(decl) => { - visitor.visit_variable_declaration(decl); - } - match_assignment_target!(ForStatementLeft) => { - visitor.visit_assignment_target(left.to_assignment_target_mut()); - } - ForStatementLeft::UsingDeclaration(decl) => { - visitor.visit_using_declaration(decl); - } - } - } - - pub fn walk_if_statement_mut<'a, V: VisitMut<'a>>(visitor: &mut V, stmt: &mut IfStatement<'a>) { - let kind = AstType::IfStatement; - visitor.enter_node(kind); - visitor.visit_expression(&mut stmt.test); - visitor.visit_statement(&mut stmt.consequent); - if let Some(alternate) = &mut stmt.alternate { - visitor.visit_statement(alternate); - } - visitor.leave_node(kind); - } - - pub fn walk_labeled_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut LabeledStatement<'a>, - ) { - let kind = AstType::LabeledStatement; - visitor.enter_node(kind); - visitor.visit_label_identifier(&mut stmt.label); - visitor.visit_statement(&mut stmt.body); - visitor.leave_node(kind); - } - - pub fn walk_return_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut ReturnStatement<'a>, - ) { - let kind = AstType::ReturnStatement; - visitor.enter_node(kind); - if let Some(arg) = &mut stmt.argument { - visitor.visit_expression(arg); - } - visitor.leave_node(kind); - } - - pub fn walk_switch_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut SwitchStatement<'a>, - ) { - let kind = AstType::SwitchStatement; - visitor.enter_node(kind); - visitor.visit_expression(&mut stmt.discriminant); - visitor.enter_scope(ScopeFlags::empty()); - for case in stmt.cases.iter_mut() { - visitor.visit_switch_case(case); - } - visitor.leave_scope(); - visitor.leave_node(kind); - } - - pub fn walk_switch_case_mut<'a, V: VisitMut<'a>>(visitor: &mut V, case: &mut SwitchCase<'a>) { - let kind = AstType::SwitchCase; - visitor.enter_node(kind); - if let Some(expr) = &mut case.test { - visitor.visit_expression(expr); - } - visitor.visit_statements(&mut case.consequent); - visitor.leave_node(kind); - } - - pub fn walk_throw_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut ThrowStatement<'a>, - ) { - let kind = AstType::ThrowStatement; - visitor.enter_node(kind); - visitor.visit_expression(&mut stmt.argument); - visitor.leave_node(kind); - } - - pub fn walk_try_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut TryStatement<'a>, - ) { - let kind = AstType::TryStatement; - visitor.enter_node(kind); - visitor.visit_block_statement(&mut stmt.block); - if let Some(handler) = &mut stmt.handler { - visitor.visit_catch_clause(handler); - } - if let Some(finalizer) = &mut stmt.finalizer { - visitor.visit_finally_clause(finalizer); - } - visitor.leave_node(kind); - } - - pub fn walk_catch_clause_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - clause: &mut CatchClause<'a>, - ) { - let kind = AstType::CatchClause; - visitor.enter_scope(ScopeFlags::empty()); - visitor.enter_node(kind); - if let Some(param) = &mut clause.param { - visitor.visit_catch_parameter(param); - } - visitor.visit_statements(&mut clause.body.body); - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_catch_parameter_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - param: &mut CatchParameter<'a>, - ) { - let kind = AstType::CatchParameter; - visitor.enter_node(kind); - visitor.visit_binding_pattern(&mut param.pattern); - visitor.leave_node(kind); - } - - pub fn walk_finally_clause_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - clause: &mut BlockStatement<'a>, - ) { - let kind = AstType::FinallyClause; - visitor.enter_scope(ScopeFlags::empty()); - visitor.enter_node(kind); - visitor.visit_statements(&mut clause.body); - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_while_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut WhileStatement<'a>, - ) { - let kind = AstType::WhileStatement; - visitor.enter_node(kind); - visitor.visit_expression(&mut stmt.test); - visitor.visit_statement(&mut stmt.body); - visitor.leave_node(kind); - } - - pub fn walk_with_statement_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - stmt: &mut WithStatement<'a>, - ) { - let kind = AstType::WithStatement; - visitor.enter_node(kind); - visitor.visit_expression(&mut stmt.object); - visitor.visit_statement(&mut stmt.body); - visitor.leave_node(kind); - } - - pub fn walk_directive_mut<'a, V: VisitMut<'a>>(visitor: &mut V, directive: &mut Directive<'a>) { - let kind = AstType::Directive; - visitor.enter_node(kind); - visitor.visit_string_literal(&mut directive.expression); - visitor.leave_node(kind); - } - - /* ---------- Declaration ---------- */ - - pub fn walk_variable_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut VariableDeclaration<'a>, - ) { - let kind = AstType::VariableDeclaration; - visitor.enter_node(kind); - for declarator in decl.declarations.iter_mut() { - visitor.visit_variable_declarator(declarator); - } - visitor.leave_node(kind); - } - - pub fn walk_variable_declarator_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - declarator: &mut VariableDeclarator<'a>, - ) { - let kind = AstType::VariableDeclarator; - visitor.enter_node(kind); - visitor.visit_binding_pattern(&mut declarator.id); - if let Some(init) = &mut declarator.init { - visitor.visit_expression(init); - } - visitor.leave_node(kind); - } - - pub fn walk_using_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - declaration: &mut UsingDeclaration<'a>, - ) { - let kind = AstType::UsingDeclaration; - visitor.enter_node(kind); - for decl in declaration.declarations.iter_mut() { - visitor.visit_variable_declarator(decl); - } - visitor.leave_node(kind); - } - - /* ---------- Function ---------- */ - - pub fn walk_function_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - func: &mut Function<'a>, - flags: Option, - ) { - let kind = AstType::Function; - visitor.enter_scope({ - let mut flags = flags.unwrap_or(ScopeFlags::empty()) | ScopeFlags::Function; - if func.is_strict() { - flags |= ScopeFlags::StrictMode; - } - flags - }); - visitor.enter_node(kind); - if let Some(ident) = &mut func.id { - visitor.visit_binding_identifier(ident); - } - visitor.visit_formal_parameters(&mut func.params); - if let Some(body) = &mut func.body { - visitor.visit_function_body(body); - } - if let Some(parameters) = &mut func.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - if let Some(annotation) = &mut func.return_type { - visitor.visit_ts_type_annotation(annotation); - } - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_function_body_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - body: &mut FunctionBody<'a>, - ) { - let kind = AstType::FunctionBody; - visitor.enter_node(kind); - for directive in body.directives.iter_mut() { - visitor.visit_directive(directive); - } - visitor.visit_statements(&mut body.statements); - visitor.leave_node(kind); - } - - pub fn walk_formal_parameters_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - params: &mut FormalParameters<'a>, - ) { - let kind = AstType::FormalParameters; - visitor.enter_node(kind); - for param in params.items.iter_mut() { - visitor.visit_formal_parameter(param); - } - if let Some(rest) = &mut params.rest { - visitor.visit_rest_element(rest); - } - visitor.leave_node(kind); - } - - pub fn walk_formal_parameter_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - param: &mut FormalParameter<'a>, - ) { - let kind = AstType::FormalParameter; - visitor.enter_node(kind); - for decorator in param.decorators.iter_mut() { - visitor.visit_decorator(decorator); - } - visitor.visit_binding_pattern(&mut param.pattern); - visitor.leave_node(kind); - } - - /* ---------- Class ---------- */ - - pub fn walk_decorator_mut<'a, V: VisitMut<'a>>(visitor: &mut V, decorator: &mut Decorator<'a>) { - let kind = AstType::Decorator; - visitor.enter_node(kind); - visitor.visit_expression(&mut decorator.expression); - visitor.leave_node(kind); - } - - pub fn walk_class_mut<'a, V: VisitMut<'a>>(visitor: &mut V, class: &mut Class<'a>) { - for decorator in class.decorators.iter_mut() { - visitor.visit_decorator(decorator); - } - - let kind = AstType::Class; - - // FIXME(don): Should we enter a scope when visiting class declarations? - let is_class_expr = class.r#type == ClassType::ClassExpression; - if is_class_expr { - // Class expressions create a temporary scope with the class name as its only variable - // E.g., `let c = class A { foo() { console.log(A) } }` - visitor.enter_scope(ScopeFlags::empty()); - } - - visitor.enter_node(kind); - if let Some(id) = &mut class.id { - visitor.visit_binding_identifier(id); - } - if let Some(parameters) = &mut class.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - - if let Some(super_class) = &mut class.super_class { - visitor.visit_class_heritage(super_class); - } - if let Some(super_parameters) = &mut class.super_type_parameters { - visitor.visit_ts_type_parameter_instantiation(super_parameters); - } - visitor.visit_class_body(&mut class.body); - visitor.leave_node(kind); - if is_class_expr { - visitor.leave_scope(); - } - } - - pub fn walk_class_heritage_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut Expression<'a>, - ) { - let kind = AstType::ClassHeritage; - visitor.enter_node(kind); - visitor.visit_expression(expr); - visitor.leave_node(kind); - } - - pub fn walk_class_body_mut<'a, V: VisitMut<'a>>(visitor: &mut V, body: &mut ClassBody<'a>) { - for elem in body.body.iter_mut() { - visitor.visit_class_element(elem); - } - } - - pub fn walk_class_element_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - elem: &mut ClassElement<'a>, - ) { - match elem { - ClassElement::StaticBlock(block) => visitor.visit_static_block(block), - ClassElement::MethodDefinition(def) => visitor.visit_method_definition(def), - ClassElement::PropertyDefinition(def) => visitor.visit_property_definition(def), - ClassElement::AccessorProperty(_def) => { /* TODO */ } - ClassElement::TSIndexSignature(sig) => visitor.visit_ts_index_signature(sig), - } - } - - pub fn walk_static_block_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - block: &mut StaticBlock<'a>, - ) { - let kind = AstType::StaticBlock; - visitor.enter_scope(ScopeFlags::ClassStaticBlock); - visitor.enter_node(kind); - visitor.visit_statements(&mut block.body); - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_method_definition_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - def: &mut MethodDefinition<'a>, - ) { - let kind = AstType::MethodDefinition; - visitor.enter_node(kind); - for decorator in def.decorators.iter_mut() { - visitor.visit_decorator(decorator); - } - - let flags = match def.kind { - MethodDefinitionKind::Get => ScopeFlags::GetAccessor, - MethodDefinitionKind::Set => ScopeFlags::SetAccessor, - MethodDefinitionKind::Constructor => ScopeFlags::Constructor, - MethodDefinitionKind::Method => ScopeFlags::empty(), - }; - visitor.visit_property_key(&mut def.key); - visitor.visit_function(&mut def.value, Some(flags)); - visitor.leave_node(kind); - } - - pub fn walk_property_definition_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - def: &mut PropertyDefinition<'a>, - ) { - let kind = AstType::PropertyDefinition; - visitor.enter_node(kind); - for decorator in def.decorators.iter_mut() { - visitor.visit_decorator(decorator); - } - visitor.visit_property_key(&mut def.key); - if let Some(value) = &mut def.value { - visitor.visit_expression(value); - } - if let Some(annotation) = &mut def.type_annotation { - visitor.visit_ts_type_annotation(annotation); - } - visitor.leave_node(kind); - } - - /* ---------- Expression ---------- */ - - pub fn walk_expression_mut<'a, V: VisitMut<'a>>(visitor: &mut V, expr: &mut Expression<'a>) { - match expr { - Expression::BigIntLiteral(lit) => visitor.visit_bigint_literal(lit), - Expression::BooleanLiteral(lit) => visitor.visit_boolean_literal(lit), - Expression::NullLiteral(lit) => visitor.visit_null_literal(lit), - Expression::NumericLiteral(lit) => visitor.visit_number_literal(lit), - Expression::RegExpLiteral(lit) => visitor.visit_reg_expr_literal(lit), - Expression::StringLiteral(lit) => visitor.visit_string_literal(lit), - Expression::TemplateLiteral(lit) => visitor.visit_template_literal(lit), - - Expression::Identifier(ident) => visitor.visit_identifier_reference(ident), - Expression::MetaProperty(meta) => visitor.visit_meta_property(meta), - - Expression::ArrayExpression(expr) => visitor.visit_array_expression(expr), - Expression::ArrowFunctionExpression(expr) => visitor.visit_arrow_expression(expr), - Expression::AssignmentExpression(expr) => visitor.visit_assignment_expression(expr), - Expression::AwaitExpression(expr) => visitor.visit_await_expression(expr), - Expression::BinaryExpression(expr) => visitor.visit_binary_expression(expr), - Expression::CallExpression(expr) => visitor.visit_call_expression(expr), - Expression::ChainExpression(expr) => visitor.visit_chain_expression(expr), - Expression::ClassExpression(expr) => visitor.visit_class(expr), - Expression::ConditionalExpression(expr) => visitor.visit_conditional_expression(expr), - Expression::FunctionExpression(expr) => visitor.visit_function(expr, None), - Expression::ImportExpression(expr) => visitor.visit_import_expression(expr), - Expression::LogicalExpression(expr) => visitor.visit_logical_expression(expr), - match_member_expression!(Expression) => { - visitor.visit_member_expression(expr.to_member_expression_mut()); - } - Expression::NewExpression(expr) => visitor.visit_new_expression(expr), - Expression::ObjectExpression(expr) => visitor.visit_object_expression(expr), - Expression::ParenthesizedExpression(expr) => { - visitor.visit_parenthesized_expression(expr); - } - Expression::PrivateInExpression(expr) => visitor.visit_private_in_expression(expr), - Expression::SequenceExpression(expr) => visitor.visit_sequence_expression(expr), - Expression::TaggedTemplateExpression(expr) => { - visitor.visit_tagged_template_expression(expr); - } - Expression::ThisExpression(expr) => visitor.visit_this_expression(expr), - Expression::UnaryExpression(expr) => visitor.visit_unary_expression(expr), - Expression::UpdateExpression(expr) => visitor.visit_update_expression(expr), - Expression::YieldExpression(expr) => visitor.visit_yield_expression(expr), - Expression::Super(expr) => visitor.visit_super(expr), - Expression::JSXElement(elem) => visitor.visit_jsx_element(elem), - Expression::JSXFragment(elem) => visitor.visit_jsx_fragment(elem), - - Expression::TSAsExpression(expr) => visitor.visit_ts_as_expression(expr), - Expression::TSSatisfiesExpression(expr) => visitor.visit_ts_satisfies_expression(expr), - Expression::TSNonNullExpression(expr) => visitor.visit_ts_non_null_expression(expr), - Expression::TSTypeAssertion(expr) => visitor.visit_ts_type_assertion(expr), - Expression::TSInstantiationExpression(expr) => { - visitor.visit_ts_instantiation_expression(expr); - } - } - } - - pub fn walk_meta_property_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _meta: &mut MetaProperty<'a>, - ) { - let kind = AstType::MetaProperty; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_array_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut ArrayExpression<'a>, - ) { - let kind = AstType::ArrayExpression; - visitor.enter_node(kind); - for elem in expr.elements.iter_mut() { - visitor.visit_array_expression_element(elem); - } - visitor.leave_node(kind); - } - - pub fn walk_array_expression_element_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - arg: &mut ArrayExpressionElement<'a>, - ) { - let kind = AstType::ArrayExpressionElement; - visitor.enter_node(kind); - match arg { - ArrayExpressionElement::SpreadElement(spread) => visitor.visit_spread_element(spread), - match_expression!(ArrayExpressionElement) => { - visitor.visit_expression_array_element(arg.to_expression_mut()); - } - ArrayExpressionElement::Elision(elision) => visitor.visit_elision(elision), - } - visitor.leave_node(kind); - } - - pub fn walk_argument_mut<'a, V: VisitMut<'a>>(visitor: &mut V, arg: &mut Argument<'a>) { - let kind = AstType::Argument; - visitor.enter_node(kind); - match arg { - Argument::SpreadElement(spread) => visitor.visit_spread_element(spread), - match_expression!(Argument) => visitor.visit_expression(arg.to_expression_mut()), - } - visitor.leave_node(kind); - } - - pub fn walk_spread_element_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - elem: &mut SpreadElement<'a>, - ) { - let kind = AstType::SpreadElement; - visitor.enter_node(kind); - visitor.visit_expression(&mut elem.argument); - visitor.leave_node(kind); - } - - pub fn walk_expression_array_element_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut Expression<'a>, - ) { - let kind = AstType::ExpressionArrayElement; - visitor.enter_node(kind); - visitor.visit_expression(expr); - visitor.leave_node(kind); - } - - pub fn walk_elision_mut<'a, V: VisitMut<'a>>(visitor: &mut V, _elision: &mut Elision) { - let kind = AstType::Elision; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_assignment_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut AssignmentExpression<'a>, - ) { - let kind = AstType::AssignmentExpression; - visitor.enter_node(kind); - visitor.visit_assignment_target(&mut expr.left); - visitor.visit_expression(&mut expr.right); - visitor.leave_node(kind); - } - - pub fn walk_arrow_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut ArrowFunctionExpression<'a>, - ) { - let kind = AstType::ArrowFunctionExpression; - visitor.enter_scope(ScopeFlags::Function | ScopeFlags::Arrow); - visitor.enter_node(kind); - visitor.visit_formal_parameters(&mut expr.params); - visitor.visit_function_body(&mut expr.body); - if let Some(parameters) = &mut expr.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_await_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut AwaitExpression<'a>, - ) { - let kind = AstType::AwaitExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.argument); - visitor.leave_node(kind); - } - - pub fn walk_binary_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut BinaryExpression<'a>, - ) { - let kind = AstType::BinaryExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.left); - visitor.visit_expression(&mut expr.right); - visitor.leave_node(kind); - } - - pub fn walk_call_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut CallExpression<'a>, - ) { - let kind = AstType::CallExpression; - visitor.enter_node(kind); - for arg in expr.arguments.iter_mut() { - visitor.visit_argument(arg); - } - visitor.visit_expression(&mut expr.callee); - if let Some(parameters) = &mut expr.type_parameters { - visitor.visit_ts_type_parameter_instantiation(parameters); - } - visitor.leave_node(kind); - } - - pub fn walk_chain_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut ChainExpression<'a>, - ) { - let kind = AstType::ChainExpression; - visitor.enter_node(kind); - visitor.visit_chain_element(&mut expr.expression); - visitor.leave_node(kind); - } - - pub fn walk_chain_element_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - elem: &mut ChainElement<'a>, - ) { - match elem { - ChainElement::CallExpression(expr) => visitor.visit_call_expression(expr), - match_member_expression!(ChainElement) => { - visitor.visit_member_expression(elem.to_member_expression_mut()); - } - } - } - - pub fn walk_conditional_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut ConditionalExpression<'a>, - ) { - let kind = AstType::ConditionalExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.test); - visitor.visit_expression(&mut expr.consequent); - visitor.visit_expression(&mut expr.alternate); - visitor.leave_node(kind); - } - - pub fn walk_import_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut ImportExpression<'a>, - ) { - visitor.visit_expression(&mut expr.source); - for arg in expr.arguments.iter_mut() { - visitor.visit_expression(arg); - } - } - - pub fn walk_logical_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut LogicalExpression<'a>, - ) { - let kind = AstType::LogicalExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.left); - visitor.visit_expression(&mut expr.right); - visitor.leave_node(kind); - } - - pub fn walk_member_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut MemberExpression<'a>, - ) { - let kind = AstType::MemberExpression; - visitor.enter_node(kind); - match expr { - MemberExpression::ComputedMemberExpression(expr) => { - visitor.visit_computed_member_expression(expr); - } - MemberExpression::StaticMemberExpression(expr) => { - visitor.visit_static_member_expression(expr); - } - MemberExpression::PrivateFieldExpression(expr) => { - visitor.visit_private_field_expression(expr); - } - } - visitor.leave_node(kind); - } - - pub fn walk_computed_member_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut ComputedMemberExpression<'a>, - ) { - visitor.visit_expression(&mut expr.object); - visitor.visit_expression(&mut expr.expression); - } - - pub fn walk_static_member_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut StaticMemberExpression<'a>, - ) { - visitor.visit_expression(&mut expr.object); - visitor.visit_identifier_name(&mut expr.property); - } - - pub fn walk_private_field_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut PrivateFieldExpression<'a>, - ) { - visitor.visit_expression(&mut expr.object); - visitor.visit_private_identifier(&mut expr.field); - } - - pub fn walk_new_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut NewExpression<'a>, - ) { - let kind = AstType::NewExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.callee); - if let Some(parameters) = &mut expr.type_parameters { - visitor.visit_ts_type_parameter_instantiation(parameters); - } - for arg in expr.arguments.iter_mut() { - visitor.visit_argument(arg); - } - visitor.leave_node(kind); - } - - pub fn walk_object_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut ObjectExpression<'a>, - ) { - let kind = AstType::ObjectExpression; - visitor.enter_node(kind); - for prop in expr.properties.iter_mut() { - visitor.visit_object_property_kind(prop); - } - visitor.leave_node(kind); - } - - pub fn walk_object_property_kind_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - prop: &mut ObjectPropertyKind<'a>, - ) { - match prop { - ObjectPropertyKind::ObjectProperty(prop) => visitor.visit_object_property(prop), - ObjectPropertyKind::SpreadProperty(elem) => visitor.visit_spread_element(elem), - } - } - - pub fn walk_object_property_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - prop: &mut ObjectProperty<'a>, - ) { - let kind = AstType::ObjectProperty; - visitor.enter_node(kind); - visitor.visit_property_key(&mut prop.key); - visitor.visit_expression(&mut prop.value); - if let Some(init) = &mut prop.init { - visitor.visit_expression(init); - } - visitor.leave_node(kind); - } - - pub fn walk_property_key_mut<'a, V: VisitMut<'a>>(visitor: &mut V, key: &mut PropertyKey<'a>) { - let kind = AstType::PropertyKey; - visitor.enter_node(kind); - match key { - PropertyKey::StaticIdentifier(ident) => visitor.visit_identifier_name(ident), - PropertyKey::PrivateIdentifier(ident) => visitor.visit_private_identifier(ident), - match_expression!(PropertyKey) => visitor.visit_expression(key.to_expression_mut()), - } - visitor.leave_node(kind); - } - - pub fn walk_parenthesized_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut ParenthesizedExpression<'a>, - ) { - let kind = AstType::ParenthesizedExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.expression); - visitor.leave_node(kind); - } - - pub fn walk_private_in_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut PrivateInExpression<'a>, - ) { - visitor.visit_private_identifier(&mut expr.left); - visitor.visit_expression(&mut expr.right); - } - - pub fn walk_sequence_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut SequenceExpression<'a>, - ) { - let kind = AstType::SequenceExpression; - visitor.enter_node(kind); - for expr in expr.expressions.iter_mut() { - visitor.visit_expression(expr); - } - visitor.leave_node(kind); - } - - pub fn walk_tagged_template_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut TaggedTemplateExpression<'a>, - ) { - let kind = AstType::TaggedTemplateExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.tag); - visitor.visit_template_literal(&mut expr.quasi); - visitor.leave_node(kind); - } - - pub fn walk_this_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _expr: &mut ThisExpression, - ) { - let kind = AstType::ThisExpression; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_unary_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut UnaryExpression<'a>, - ) { - let kind = AstType::UnaryExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.argument); - visitor.leave_node(kind); - } - - pub fn walk_update_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut UpdateExpression<'a>, - ) { - let kind = AstType::UpdateExpression; - visitor.enter_node(kind); - visitor.visit_simple_assignment_target(&mut expr.argument); - visitor.leave_node(kind); - } - - pub fn walk_yield_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut YieldExpression<'a>, - ) { - let kind = AstType::YieldExpression; - visitor.enter_node(kind); - if let Some(argument) = &mut expr.argument { - visitor.visit_expression(argument); - } - visitor.leave_node(kind); - } - - pub fn walk_super_mut<'a, V: VisitMut<'a>>(visitor: &mut V, _expr: &mut Super) { - let kind = AstType::Super; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_assignment_target_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - target: &mut AssignmentTarget<'a>, - ) { - let kind = AstType::AssignmentTarget; - visitor.enter_node(kind); - match target { - match_simple_assignment_target!(AssignmentTarget) => { - visitor.visit_simple_assignment_target(target.to_simple_assignment_target_mut()); - } - match_assignment_target_pattern!(AssignmentTarget) => { - visitor.visit_assignment_target_pattern(target.to_assignment_target_pattern_mut()); - } - } - visitor.leave_node(kind); - } - - pub fn walk_simple_assignment_target_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - target: &mut SimpleAssignmentTarget<'a>, - ) { - let kind = AstType::SimpleAssignmentTarget; - visitor.enter_node(kind); - match target { - SimpleAssignmentTarget::AssignmentTargetIdentifier(ident) => { - visitor.visit_identifier_reference(ident); - } - match_member_expression!(SimpleAssignmentTarget) => { - visitor.visit_member_expression(target.to_member_expression_mut()); - } - SimpleAssignmentTarget::TSAsExpression(expr) => { - visitor.visit_expression(&mut expr.expression); - } - SimpleAssignmentTarget::TSSatisfiesExpression(expr) => { - visitor.visit_expression(&mut expr.expression); - } - SimpleAssignmentTarget::TSNonNullExpression(expr) => { - visitor.visit_expression(&mut expr.expression); - } - SimpleAssignmentTarget::TSTypeAssertion(expr) => { - visitor.visit_expression(&mut expr.expression); - } - SimpleAssignmentTarget::TSInstantiationExpression(expr) => { - visitor.visit_expression(&mut expr.expression); - } - } - visitor.leave_node(kind); - } - - pub fn walk_assignment_target_pattern_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - pat: &mut AssignmentTargetPattern<'a>, - ) { - match pat { - AssignmentTargetPattern::ArrayAssignmentTarget(target) => { - visitor.visit_array_assignment_target(target); - } - AssignmentTargetPattern::ObjectAssignmentTarget(target) => { - visitor.visit_object_assignment_target(target); - } - } - } - - pub fn walk_array_assignment_target_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - target: &mut ArrayAssignmentTarget<'a>, - ) { - for element in target.elements.iter_mut().flatten() { - visitor.visit_assignment_target_maybe_default(element); - } - if let Some(target) = &mut target.rest { - visitor.visit_assignment_target_rest(target); - } - } - - pub fn walk_assignment_target_maybe_default_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - target: &mut AssignmentTargetMaybeDefault<'a>, - ) { - match target { - match_assignment_target!(AssignmentTargetMaybeDefault) => { - visitor.visit_assignment_target(target.to_assignment_target_mut()); - } - AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(target) => { - visitor.visit_assignment_target_with_default(target); - } - } - } - - pub fn walk_assignment_target_with_default_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - target: &mut AssignmentTargetWithDefault<'a>, - ) { - let kind = AstType::AssignmentTargetWithDefault; - visitor.enter_node(kind); - visitor.visit_assignment_target(&mut target.binding); - visitor.visit_expression(&mut target.init); - visitor.leave_node(kind); - } - - pub fn walk_object_assignment_target_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - target: &mut ObjectAssignmentTarget<'a>, - ) { - for property in target.properties.iter_mut() { - visitor.visit_assignment_target_property(property); - } - if let Some(target) = &mut target.rest { - visitor.visit_assignment_target_rest(target); - } - } - - pub fn walk_assignment_target_property_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - property: &mut AssignmentTargetProperty<'a>, - ) { - match property { - AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(ident) => { - visitor.visit_assignment_target_property_identifier(ident); - } - AssignmentTargetProperty::AssignmentTargetPropertyProperty(prop) => { - visitor.visit_assignment_target_property_property(prop); - } - } - } - - pub fn walk_assignment_target_property_identifier_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ident: &mut AssignmentTargetPropertyIdentifier<'a>, - ) { - visitor.visit_identifier_reference(&mut ident.binding); - if let Some(expr) = &mut ident.init { - visitor.visit_expression(expr); - } - } - - pub fn walk_assignment_target_property_property_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - property: &mut AssignmentTargetPropertyProperty<'a>, - ) { - visitor.visit_property_key(&mut property.name); - visitor.visit_assignment_target_maybe_default(&mut property.binding); - } - - pub fn walk_assignment_target_rest_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - rest: &mut AssignmentTargetRest<'a>, - ) { - visitor.visit_assignment_target(&mut rest.target); - } - - /* ---------- Expression ---------- */ - - pub fn walk_jsx_element_mut<'a, V: VisitMut<'a>>(visitor: &mut V, elem: &mut JSXElement<'a>) { - let kind = AstType::JSXElement; - visitor.enter_node(kind); - visitor.visit_jsx_opening_element(&mut elem.opening_element); - for child in elem.children.iter_mut() { - visitor.visit_jsx_child(child); - } - if let Some(closing_elem) = &mut elem.closing_element { - visitor.visit_jsx_closing_element(closing_elem); - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_opening_element_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - elem: &mut JSXOpeningElement<'a>, - ) { - let kind = AstType::JSXOpeningElement; - visitor.enter_node(kind); - - visitor.visit_jsx_element_name(&mut elem.name); - for attribute in elem.attributes.iter_mut() { - visitor.visit_jsx_attribute_item(attribute); - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_closing_element_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - elem: &mut JSXClosingElement<'a>, - ) { - let kind = AstType::JSXClosingElement; - visitor.enter_node(kind); - visitor.visit_jsx_element_name(&mut elem.name); - visitor.leave_node(kind); - } - - pub fn walk_jsx_element_name_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - name: &mut JSXElementName<'a>, - ) { - let kind = AstType::JSXElementName; - visitor.enter_node(kind); - match name { - JSXElementName::Identifier(ident) => visitor.visit_jsx_identifier(ident), - JSXElementName::MemberExpression(expr) => visitor.visit_jsx_member_expression(expr), - JSXElementName::NamespacedName(name) => visitor.visit_jsx_namespaced_name(name), - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_identifier_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _ident: &mut JSXIdentifier<'a>, - ) { - let kind = AstType::JSXIdentifier; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_jsx_member_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut JSXMemberExpression<'a>, - ) { - let kind = AstType::JSXMemberExpression; - visitor.enter_node(kind); - visitor.visit_jsx_member_expression_object(&mut expr.object); - visitor.visit_jsx_identifier(&mut expr.property); - visitor.leave_node(kind); - } - - pub fn walk_jsx_member_expression_object_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut JSXMemberExpressionObject<'a>, - ) { - let kind = AstType::JSXMemberExpressionObject; - visitor.enter_node(kind); - match expr { - JSXMemberExpressionObject::Identifier(ident) => visitor.visit_jsx_identifier(ident), - JSXMemberExpressionObject::MemberExpression(expr) => { - visitor.visit_jsx_member_expression(expr); - } - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_namespaced_name_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - name: &mut JSXNamespacedName<'a>, - ) { - let kind = AstType::JSXNamespacedName; - visitor.enter_node(kind); - visitor.visit_jsx_identifier(&mut name.namespace); - visitor.visit_jsx_identifier(&mut name.property); - visitor.leave_node(kind); - } - - pub fn walk_jsx_attribute_item_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - item: &mut JSXAttributeItem<'a>, - ) { - let kind = AstType::JSXAttributeItem; - visitor.enter_node(kind); - match item { - JSXAttributeItem::Attribute(attribute) => visitor.visit_jsx_attribute(attribute), - JSXAttributeItem::SpreadAttribute(attribute) => { - visitor.visit_jsx_spread_attribute(attribute); - } - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_attribute_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - attribute: &mut JSXAttribute<'a>, - ) { - if let Some(value) = &mut attribute.value { - visitor.visit_jsx_attribute_value(value); - } - } - - pub fn walk_jsx_spread_attribute_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - attribute: &mut JSXSpreadAttribute<'a>, - ) { - visitor.visit_expression(&mut attribute.argument); - } - - pub fn walk_jsx_attribute_value_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - value: &mut JSXAttributeValue<'a>, - ) { - match value { - JSXAttributeValue::ExpressionContainer(expr) => { - visitor.visit_jsx_expression_container(expr); - } - JSXAttributeValue::Element(elem) => visitor.visit_jsx_element(elem), - JSXAttributeValue::Fragment(elem) => visitor.visit_jsx_fragment(elem), - JSXAttributeValue::StringLiteral(_) => {} - } - } - - pub fn walk_jsx_expression_container_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut JSXExpressionContainer<'a>, - ) { - let kind = AstType::JSXExpressionContainer; - visitor.enter_node(kind); - visitor.visit_jsx_expression(&mut expr.expression); - visitor.leave_node(kind); - } - - pub fn walk_jsx_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut JSXExpression<'a>, - ) { - match expr { - match_expression!(JSXExpression) => visitor.visit_expression(expr.to_expression_mut()), - JSXExpression::EmptyExpression(_) => {} - } - } - - pub fn walk_jsx_fragment_mut<'a, V: VisitMut<'a>>(visitor: &mut V, elem: &mut JSXFragment<'a>) { - let kind = AstType::JSXFragment; - visitor.enter_node(kind); - for child in elem.children.iter_mut() { - visitor.visit_jsx_child(child); - } - visitor.leave_node(kind); - } - - pub fn walk_jsx_child_mut<'a, V: VisitMut<'a>>(visitor: &mut V, child: &mut JSXChild<'a>) { - match child { - JSXChild::Element(elem) => visitor.visit_jsx_element(elem), - JSXChild::Fragment(elem) => visitor.visit_jsx_fragment(elem), - JSXChild::ExpressionContainer(expr) => visitor.visit_jsx_expression_container(expr), - JSXChild::Spread(expr) => visitor.visit_jsx_spread_child(expr), - JSXChild::Text(expr) => visitor.visit_jsx_text(expr), - } - } - - pub fn walk_jsx_spread_child_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - child: &mut JSXSpreadChild<'a>, - ) { - visitor.visit_expression(&mut child.expression); - } - - pub fn walk_jsx_text_mut<'a, V: VisitMut<'a>>(visitor: &mut V, _child: &JSXText<'a>) { - let kind = AstType::JSXText; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - /* ---------- Pattern ---------- */ - - pub fn walk_binding_pattern_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - pat: &mut BindingPattern<'a>, - ) { - match &mut pat.kind { - BindingPatternKind::BindingIdentifier(ident) => { - visitor.visit_binding_identifier(ident); - } - BindingPatternKind::ObjectPattern(pat) => visitor.visit_object_pattern(pat), - BindingPatternKind::ArrayPattern(pat) => visitor.visit_array_pattern(pat), - BindingPatternKind::AssignmentPattern(pat) => visitor.visit_assignment_pattern(pat), - } - if let Some(type_annotation) = &mut pat.type_annotation { - visitor.visit_ts_type_annotation(type_annotation); - } - } - - pub fn walk_binding_identifier_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _ident: &mut BindingIdentifier<'a>, - ) { - let kind = AstType::BindingIdentifier; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_object_pattern_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - pat: &mut ObjectPattern<'a>, - ) { - let kind = AstType::ObjectPattern; - visitor.enter_node(kind); - for prop in pat.properties.iter_mut() { - visitor.visit_binding_property(prop); - } - if let Some(rest) = &mut pat.rest { - visitor.visit_rest_element(rest); - } - visitor.leave_node(kind); - } - - pub fn walk_binding_property_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - prop: &mut BindingProperty<'a>, - ) { - visitor.visit_property_key(&mut prop.key); - visitor.visit_binding_pattern(&mut prop.value); - } - - pub fn walk_array_pattern_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - pat: &mut ArrayPattern<'a>, - ) { - let kind = AstType::ArrayPattern; - visitor.enter_node(kind); - for pat in pat.elements.iter_mut().flatten() { - visitor.visit_binding_pattern(pat); - } - if let Some(rest) = &mut pat.rest { - visitor.visit_rest_element(rest); - } - visitor.leave_node(kind); - } - - pub fn walk_rest_element_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - pat: &mut BindingRestElement<'a>, - ) { - let kind = AstType::BindingRestElement; - visitor.enter_node(kind); - visitor.visit_binding_pattern(&mut pat.argument); - visitor.leave_node(kind); - } - - pub fn walk_assignment_pattern_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - pat: &mut AssignmentPattern<'a>, - ) { - let kind = AstType::AssignmentPattern; - visitor.enter_node(kind); - visitor.visit_binding_pattern(&mut pat.left); - visitor.visit_expression(&mut pat.right); - visitor.leave_node(kind); - } - - /* ---------- Identifier ---------- */ - - pub fn walk_identifier_reference_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _ident: &mut IdentifierReference<'a>, - ) { - let kind = AstType::IdentifierReference; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_private_identifier_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _ident: &mut PrivateIdentifier<'a>, - ) { - let kind = AstType::PrivateIdentifier; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_label_identifier_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _ident: &mut LabelIdentifier<'a>, - ) { - let kind = AstType::LabelIdentifier; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_identifier_name_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _ident: &mut IdentifierName<'a>, - ) { - let kind = AstType::IdentifierName; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - /* ---------- Literal ---------- */ - - pub fn walk_number_literal_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _lit: &mut NumericLiteral<'a>, - ) { - let kind = AstType::NumericLiteral; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_boolean_literal_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _lit: &mut BooleanLiteral, - ) { - let kind = AstType::BooleanLiteral; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_null_literal_mut<'a, V: VisitMut<'a>>(visitor: &mut V, _lit: &mut NullLiteral) { - let kind = AstType::NullLiteral; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_bigint_literal_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _lit: &mut BigIntLiteral<'a>, - ) { - let kind = AstType::BigIntLiteral; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_string_literal_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _lit: &mut StringLiteral<'a>, - ) { - let kind = AstType::StringLiteral; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_template_literal_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - lit: &mut TemplateLiteral<'a>, - ) { - let kind = AstType::TemplateLiteral; - visitor.enter_node(kind); - for elem in lit.quasis.iter_mut() { - visitor.visit_template_element(elem); - } - for expr in lit.expressions.iter_mut() { - visitor.visit_expression(expr); - } - visitor.leave_node(kind); - } - - pub fn walk_reg_expr_literal_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - _lit: &mut RegExpLiteral<'a>, - ) { - let kind = AstType::RegExpLiteral; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_template_element_mut<'a, V: VisitMut<'a>>( - _visitor: &mut V, - _elem: &mut TemplateElement, - ) { - // noop! - } - - /* ---------- Module ---------- */ - - pub fn walk_module_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut ModuleDeclaration<'a>, - ) { - let kind = AstType::ModuleDeclaration; - visitor.enter_node(kind); - match decl { - ModuleDeclaration::ImportDeclaration(decl) => { - visitor.visit_import_declaration(decl); - } - ModuleDeclaration::ExportAllDeclaration(decl) => { - visitor.visit_export_all_declaration(decl); - } - ModuleDeclaration::ExportDefaultDeclaration(decl) => { - visitor.visit_export_default_declaration(decl); - } - ModuleDeclaration::ExportNamedDeclaration(decl) => { - visitor.visit_export_named_declaration(decl); - } - ModuleDeclaration::TSExportAssignment(decl) => { - visitor.visit_expression(&mut decl.expression); - } - ModuleDeclaration::TSNamespaceExportDeclaration(_) => {} - } - visitor.leave_node(kind); - } - - pub fn walk_import_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut ImportDeclaration<'a>, - ) { - let kind = AstType::ImportDeclaration; - visitor.enter_node(kind); - if let Some(specifiers) = &mut decl.specifiers { - for specifier in specifiers.iter_mut() { - visitor.visit_import_declaration_specifier(specifier); - } - } - visitor.visit_string_literal(&mut decl.source); - if let Some(with_clause) = &mut decl.with_clause { - visitor.visit_with_clause(with_clause); - } - visitor.leave_node(kind); - } - - pub fn walk_with_clause_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - with_clause: &mut WithClause<'a>, - ) { - for attribute in with_clause.with_entries.iter_mut() { - visitor.visit_import_attribute(attribute); - } - } - - pub fn walk_import_attribute_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - attribute: &mut ImportAttribute<'a>, - ) { - visitor.visit_import_attribute_key(&mut attribute.key); - visitor.visit_string_literal(&mut attribute.value); - } - - pub fn walk_import_attribute_key_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - key: &mut ImportAttributeKey<'a>, - ) { - match key { - ImportAttributeKey::Identifier(ident) => visitor.visit_identifier_name(ident), - ImportAttributeKey::StringLiteral(ident) => visitor.visit_string_literal(ident), - } - } - - pub fn walk_import_declaration_specifier_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - specifier: &mut ImportDeclarationSpecifier<'a>, - ) { - match specifier { - ImportDeclarationSpecifier::ImportSpecifier(specifier) => { - visitor.visit_import_specifier(specifier); - } - ImportDeclarationSpecifier::ImportDefaultSpecifier(specifier) => { - visitor.visit_import_default_specifier(specifier); - } - ImportDeclarationSpecifier::ImportNamespaceSpecifier(specifier) => { - visitor.visit_import_name_specifier(specifier); - } - } - } - - pub fn walk_import_specifier_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - specifier: &mut ImportSpecifier<'a>, - ) { - let kind = AstType::ImportSpecifier; - visitor.enter_node(kind); - // TODO: imported - visitor.visit_binding_identifier(&mut specifier.local); - visitor.leave_node(kind); - } - - pub fn walk_import_default_specifier_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - specifier: &mut ImportDefaultSpecifier<'a>, - ) { - let kind = AstType::ImportDefaultSpecifier; - visitor.enter_node(kind); - visitor.visit_binding_identifier(&mut specifier.local); - visitor.leave_node(kind); - } - - pub fn walk_import_name_specifier_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - specifier: &mut ImportNamespaceSpecifier<'a>, - ) { - let kind = AstType::ImportNamespaceSpecifier; - visitor.enter_node(kind); - visitor.visit_binding_identifier(&mut specifier.local); - visitor.leave_node(kind); - } - - pub fn walk_export_all_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut ExportAllDeclaration<'a>, - ) { - let kind = AstType::ExportAllDeclaration; - visitor.enter_node(kind); - visitor.visit_string_literal(&mut decl.source); - visitor.leave_node(kind); - } - - pub fn walk_export_default_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut ExportDefaultDeclaration<'a>, - ) { - let kind = AstType::ExportDefaultDeclaration; - visitor.enter_node(kind); - match &mut decl.declaration { - declaration @ match_expression!(ExportDefaultDeclarationKind) => { - visitor.visit_expression(declaration.to_expression_mut()); - } - ExportDefaultDeclarationKind::FunctionDeclaration(func) => { - visitor.visit_function(func, None); - } - ExportDefaultDeclarationKind::ClassDeclaration(class) => visitor.visit_class(class), - _ => {} - } - visitor.leave_node(kind); - } - - pub fn walk_export_named_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut ExportNamedDeclaration<'a>, - ) { - let kind = AstType::ExportNamedDeclaration; - visitor.enter_node(kind); - if let Some(decl) = &mut decl.declaration { - visitor.visit_declaration(decl); - } - if let Some(source) = &mut decl.source { - visitor.visit_string_literal(source); - } - visitor.leave_node(kind); - } - - pub fn walk_enum_member_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - member: &mut TSEnumMember<'a>, - ) { - let kind = AstType::TSEnumMember; - visitor.enter_node(kind); - if let Some(initializer) = &mut member.initializer { - visitor.visit_expression(initializer); - } - visitor.leave_node(kind); - } - - pub fn walk_enum_mut<'a, V: VisitMut<'a>>(visitor: &mut V, decl: &mut TSEnumDeclaration<'a>) { - let kind = AstType::TSEnumDeclaration; - visitor.enter_node(kind); - visitor.visit_binding_identifier(&mut decl.id); - visitor.enter_scope(ScopeFlags::empty()); - for member in decl.members.iter_mut() { - visitor.visit_enum_member(member); - } - visitor.leave_scope(); - visitor.leave_node(kind); - } - - pub fn walk_declaration_mut<'a, V: VisitMut<'a>>(visitor: &mut V, decl: &mut Declaration<'a>) { - match decl { - Declaration::VariableDeclaration(decl) => visitor.visit_variable_declaration(decl), - Declaration::FunctionDeclaration(func) => visitor.visit_function(func, None), - Declaration::ClassDeclaration(class) => visitor.visit_class(class), - Declaration::UsingDeclaration(decl) => visitor.visit_using_declaration(decl), - Declaration::TSModuleDeclaration(module) => { - visitor.visit_ts_module_declaration(module); - } - Declaration::TSTypeAliasDeclaration(decl) => { - visitor.visit_ts_type_alias_declaration(decl); - } - Declaration::TSEnumDeclaration(decl) => visitor.visit_enum(decl), - Declaration::TSImportEqualsDeclaration(decl) => { - visitor.visit_ts_import_equals_declaration(decl); - } - Declaration::TSInterfaceDeclaration(decl) => { - visitor.visit_ts_interface_declaration(decl); - } - } - } - - /* ---------- TypeScript ---------- */ - - pub fn walk_ts_import_equals_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut TSImportEqualsDeclaration<'a>, - ) { - let kind = AstType::TSImportEqualsDeclaration; - visitor.enter_node(kind); - visitor.visit_binding_identifier(&mut decl.id); - visitor.visit_ts_module_reference(&mut decl.module_reference); - visitor.leave_node(kind); - } - - pub fn walk_ts_module_reference_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - reference: &mut TSModuleReference<'a>, - ) { - match reference { - name @ match_ts_type_name!(TSModuleReference) => { - visitor.visit_ts_type_name(name.to_ts_type_name_mut()); - } - TSModuleReference::ExternalModuleReference(reference) => { - visitor.visit_ts_external_module_reference(reference); - } - } - } - - pub fn walk_ts_type_name_mut<'a, V: VisitMut<'a>>(visitor: &mut V, name: &mut TSTypeName<'a>) { - let kind = AstType::TSTypeName; - visitor.enter_node(kind); - match name { - TSTypeName::IdentifierReference(ident) => visitor.visit_identifier_reference(ident), - TSTypeName::QualifiedName(name) => visitor.visit_ts_qualified_name(name), - } - visitor.leave_node(kind); - } - - pub fn walk_ts_external_module_reference_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - reference: &mut TSExternalModuleReference<'a>, - ) { - let kind = AstType::TSExternalModuleReference; - visitor.enter_node(kind); - visitor.visit_string_literal(&mut reference.expression); - visitor.leave_node(kind); - } - - pub fn walk_ts_qualified_name_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - name: &mut TSQualifiedName<'a>, - ) { - let kind = AstType::TSQualifiedName; - visitor.enter_node(kind); - visitor.visit_ts_type_name(&mut name.left); - visitor.visit_identifier_name(&mut name.right); - visitor.leave_node(kind); - } - - pub fn walk_ts_module_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut TSModuleDeclaration<'a>, - ) { - let kind = AstType::TSModuleDeclaration; - visitor.enter_node(kind); - match &mut decl.id { - TSModuleDeclarationName::Identifier(ident) => visitor.visit_identifier_name(ident), - TSModuleDeclarationName::StringLiteral(lit) => visitor.visit_string_literal(lit), - } - visitor.enter_scope({ - let mut flags = ScopeFlags::TsModuleBlock; - if decl.is_strict() { - flags |= ScopeFlags::StrictMode; - } - flags - }); - match &mut decl.body { - Some(TSModuleDeclarationBody::TSModuleDeclaration(decl)) => { - visitor.visit_ts_module_declaration(decl); - } - Some(TSModuleDeclarationBody::TSModuleBlock(block)) => { - visitor.visit_ts_module_block(block); - } - None => {} - } - visitor.leave_scope(); - visitor.leave_node(kind); - } - - pub fn walk_ts_module_block_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - block: &mut TSModuleBlock<'a>, - ) { - let kind = AstType::TSModuleBlock; - visitor.enter_node(kind); - visitor.visit_statements(&mut block.body); - visitor.leave_node(kind); - } - - pub fn walk_ts_type_alias_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut TSTypeAliasDeclaration<'a>, - ) { - let kind = AstType::TSTypeAliasDeclaration; - visitor.enter_node(kind); - visitor.visit_binding_identifier(&mut decl.id); - if let Some(parameters) = &mut decl.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - visitor.visit_ts_type(&mut decl.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_interface_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - decl: &mut TSInterfaceDeclaration<'a>, - ) { - let kind = AstType::TSInterfaceDeclaration; - visitor.enter_node(kind); - visitor.visit_binding_identifier(&mut decl.id); - if let Some(parameters) = &mut decl.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - for signature in decl.body.body.iter_mut() { - visitor.visit_ts_signature(signature); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_as_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut TSAsExpression<'a>, - ) { - let kind = AstType::TSAsExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.expression); - visitor.visit_ts_type(&mut expr.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_satisfies_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut TSSatisfiesExpression<'a>, - ) { - let kind = AstType::TSSatisfiesExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.expression); - visitor.visit_ts_type(&mut expr.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_non_null_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut TSNonNullExpression<'a>, - ) { - let kind = AstType::TSNonNullExpression; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.expression); - visitor.leave_node(kind); - } - - pub fn walk_ts_type_assertion_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut TSTypeAssertion<'a>, - ) { - let kind = AstType::TSTypeAssertion; - visitor.enter_node(kind); - visitor.visit_expression(&mut expr.expression); - visitor.visit_ts_type(&mut expr.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_instantiation_expression_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - expr: &mut TSInstantiationExpression<'a>, - ) { - visitor.visit_expression(&mut expr.expression); - visitor.visit_ts_type_parameter_instantiation(&mut expr.type_parameters); - } - - pub fn walk_ts_type_annotation_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - annotation: &mut TSTypeAnnotation<'a>, - ) { - let kind = AstType::TSTypeAnnotation; - visitor.enter_node(kind); - visitor.visit_ts_type(&mut annotation.type_annotation); - visitor.leave_node(kind); - } - - pub fn walk_ts_type_mut<'a, V: VisitMut<'a>>(visitor: &mut V, ty: &mut TSType<'a>) { - match ty { - TSType::TSAnyKeyword(ty) => visitor.visit_ts_any_keyword(ty), - TSType::TSNullKeyword(ty) => visitor.visit_ts_null_keyword(ty), - TSType::TSVoidKeyword(ty) => visitor.visit_ts_void_keyword(ty), - TSType::TSIntersectionType(ty) => visitor.visit_ts_intersection_type(ty), - TSType::TSTypeReference(ty) => visitor.visit_ts_type_reference(ty), - TSType::TSUnionType(ty) => visitor.visit_ts_union_type(ty), - TSType::TSLiteralType(ty) => visitor.visit_ts_literal_type(ty), - TSType::TSArrayType(ty) => visitor.visit_ts_array_type(ty), - TSType::TSConditionalType(ty) => visitor.visit_ts_conditional_type(ty), - TSType::TSConstructorType(ty) => visitor.visit_ts_constructor_type(ty), - TSType::TSFunctionType(ty) => visitor.visit_ts_function_type(ty), - TSType::TSMappedType(ty) => visitor.visit_ts_mapped_type(ty), - TSType::TSTupleType(ty) => visitor.visit_ts_tuple_type(ty), - TSType::TSTypeOperatorType(ty) => visitor.visit_ts_type_operator_type(ty), - TSType::TSTypePredicate(ty) => visitor.visit_ts_type_predicate(ty), - TSType::TSTypeLiteral(ty) => visitor.visit_ts_type_literal(ty), - TSType::TSIndexedAccessType(ty) => visitor.visit_ts_indexed_access_type(ty), - TSType::TSTypeQuery(ty) => visitor.visit_ts_type_query(ty), - _ => {} - } - } - - pub fn walk_ts_type_literal_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSTypeLiteral<'a>, - ) { - let kind = AstType::TSTypeLiteral; - visitor.enter_node(kind); - for signature in ty.members.iter_mut() { - visitor.visit_ts_signature(signature); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_indexed_access_type_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSIndexedAccessType<'a>, - ) { - let kind = AstType::TSIndexedAccessType; - visitor.enter_node(kind); - visitor.visit_ts_type(&mut ty.object_type); - visitor.visit_ts_type(&mut ty.index_type); - visitor.leave_node(kind); - } - - pub fn walk_ts_type_predicate_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSTypePredicate<'a>, - ) { - if let Some(annotation) = &mut ty.type_annotation { - visitor.visit_ts_type_annotation(annotation); - } - } - - pub fn walk_ts_type_operator_type_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSTypeOperator<'a>, - ) { - visitor.visit_ts_type(&mut ty.type_annotation); - } - - pub fn walk_ts_tuple_type_mut<'a, V: VisitMut<'a>>(visitor: &mut V, ty: &mut TSTupleType<'a>) { - for element in ty.element_types.iter_mut() { - visitor.visit_ts_tuple_element(element); - } - } - - pub fn walk_ts_tuple_element_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSTupleElement<'a>, - ) { - match ty { - match_ts_type!(TSTupleElement) => visitor.visit_ts_type(ty.to_ts_type_mut()), - TSTupleElement::TSOptionalType(ty) => visitor.visit_ts_type(&mut ty.type_annotation), - TSTupleElement::TSRestType(ty) => visitor.visit_ts_type(&mut ty.type_annotation), - }; - } - - pub fn walk_ts_mapped_type_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSMappedType<'a>, - ) { - visitor.visit_ts_type_parameter(&mut ty.type_parameter); - if let Some(name) = &mut ty.name_type { - visitor.visit_ts_type(name); - } - if let Some(type_annotation) = &mut ty.type_annotation { - visitor.visit_ts_type(type_annotation); - } - } - - pub fn walk_ts_function_type_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSFunctionType<'a>, - ) { - visitor.visit_formal_parameters(&mut ty.params); - if let Some(parameters) = &mut ty.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - visitor.visit_ts_type_annotation(&mut ty.return_type); - } - - pub fn walk_ts_type_parameter_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSTypeParameter<'a>, - ) { - let kind = AstType::TSTypeParameter; - visitor.enter_scope(ScopeFlags::empty()); - visitor.enter_node(kind); - if let Some(constraint) = &mut ty.constraint { - visitor.visit_ts_type(constraint); - } - - if let Some(default) = &mut ty.default { - visitor.visit_ts_type(default); - } - visitor.leave_node(kind); - visitor.leave_scope(); - } - - pub fn walk_ts_type_parameter_instantiation_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSTypeParameterInstantiation<'a>, - ) { - let kind = AstType::TSTypeParameterInstantiation; - visitor.enter_node(kind); - for ts_parameter in ty.params.iter_mut() { - visitor.visit_ts_type(ts_parameter); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_type_parameter_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSTypeParameterDeclaration<'a>, - ) { - let kind = AstType::TSTypeParameterDeclaration; - visitor.enter_node(kind); - for ts_parameter in ty.params.iter_mut() { - visitor.visit_ts_type_parameter(ts_parameter); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_constructor_type_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSConstructorType<'a>, - ) { - visitor.visit_formal_parameters(&mut ty.params); - if let Some(parameters) = &mut ty.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - visitor.visit_ts_type_annotation(&mut ty.return_type); - } - - pub fn walk_ts_conditional_type_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSConditionalType<'a>, - ) { - visitor.visit_ts_type(&mut ty.check_type); - visitor.visit_ts_type(&mut ty.extends_type); - visitor.visit_ts_type(&mut ty.true_type); - visitor.visit_ts_type(&mut ty.false_type); - } - - pub fn walk_ts_array_type_mut<'a, V: VisitMut<'a>>(visitor: &mut V, ty: &mut TSArrayType<'a>) { - visitor.visit_ts_type(&mut ty.element_type); - } - - pub fn walk_ts_null_keyword_mut<'a, V: VisitMut<'a>>(visitor: &mut V, _ty: &mut TSNullKeyword) { - let kind = AstType::TSNullKeyword; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_any_keyword_mut<'a, V: VisitMut<'a>>(visitor: &mut V, _ty: &mut TSAnyKeyword) { - let kind = AstType::TSAnyKeyword; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_void_keyword_mut<'a, V: VisitMut<'a>>(visitor: &mut V, _ty: &mut TSVoidKeyword) { - let kind = AstType::TSVoidKeyword; - visitor.enter_node(kind); - visitor.leave_node(kind); - } - - pub fn walk_ts_intersection_type_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSIntersectionType<'a>, - ) { - let kind = AstType::TSIntersectionType; - visitor.enter_node(kind); - for ty in ty.types.iter_mut() { - visitor.visit_ts_type(ty); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_type_reference_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSTypeReference<'a>, - ) { - let kind = AstType::TSTypeReference; - visitor.enter_node(kind); - visitor.visit_ts_type_name(&mut ty.type_name); - if let Some(parameters) = &mut ty.type_parameters { - visitor.visit_ts_type_parameter_instantiation(parameters); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_union_type_mut<'a, V: VisitMut<'a>>(visitor: &mut V, ty: &mut TSUnionType<'a>) { - let kind = AstType::TSUnionType; - visitor.enter_node(kind); - for ty in ty.types.iter_mut() { - visitor.visit_ts_type(ty); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_literal_type_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSLiteralType<'a>, - ) { - let kind = AstType::TSLiteralType; - visitor.enter_node(kind); - match &mut ty.literal { - TSLiteral::BigIntLiteral(lit) => visitor.visit_bigint_literal(lit), - TSLiteral::BooleanLiteral(lit) => visitor.visit_boolean_literal(lit), - TSLiteral::NullLiteral(lit) => visitor.visit_null_literal(lit), - TSLiteral::NumericLiteral(lit) => visitor.visit_number_literal(lit), - TSLiteral::RegExpLiteral(lit) => visitor.visit_reg_expr_literal(lit), - TSLiteral::StringLiteral(lit) => visitor.visit_string_literal(lit), - TSLiteral::TemplateLiteral(lit) => visitor.visit_template_literal(lit), - TSLiteral::UnaryExpression(expr) => visitor.visit_unary_expression(expr), - } - visitor.leave_node(kind); - } - - pub fn walk_ts_signature_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - signature: &mut TSSignature<'a>, - ) { - match signature { - TSSignature::TSPropertySignature(sig) => visitor.visit_ts_property_signature(sig), - TSSignature::TSCallSignatureDeclaration(sig) => { - visitor.visit_ts_call_signature_declaration(sig); - } - TSSignature::TSIndexSignature(sig) => visitor.visit_ts_index_signature(sig), - TSSignature::TSMethodSignature(sig) => visitor.visit_ts_method_signature(sig), - TSSignature::TSConstructSignatureDeclaration(sig) => { - visitor.visit_ts_construct_signature_declaration(sig); - } - } - } - - pub fn walk_ts_construct_signature_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - signature: &mut TSConstructSignatureDeclaration<'a>, - ) { - visitor.visit_formal_parameters(&mut signature.params); - if let Some(parameters) = &mut signature.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - if let Some(annotation) = &mut signature.return_type { - visitor.visit_ts_type_annotation(annotation); - } - } - - pub fn walk_ts_method_signature_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - signature: &mut TSMethodSignature<'a>, - ) { - let kind = AstType::TSMethodSignature; - visitor.enter_node(kind); - visitor.visit_formal_parameters(&mut signature.params); - if let Some(parameters) = &mut signature.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - if let Some(annotation) = &mut signature.return_type { - visitor.visit_ts_type_annotation(annotation); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_index_signature_name_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - name: &mut TSIndexSignatureName<'a>, - ) { - visitor.visit_ts_type_annotation(&mut name.type_annotation); - } - - pub fn walk_ts_index_signature_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - signature: &mut TSIndexSignature<'a>, - ) { - for name in signature.parameters.iter_mut() { - visitor.visit_ts_index_signature_name(name); - } - - visitor.visit_ts_type_annotation(&mut signature.type_annotation); - } - - pub fn walk_ts_property_signature_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - signature: &mut TSPropertySignature<'a>, - ) { - let kind = AstType::TSPropertySignature; - visitor.enter_node(kind); - visitor.visit_property_key(&mut signature.key); - if let Some(annotation) = &mut signature.type_annotation { - visitor.visit_ts_type_annotation(annotation); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_call_signature_declaration_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - signature: &mut TSCallSignatureDeclaration<'a>, - ) { - visitor.visit_formal_parameters(&mut signature.params); - if let Some(parameters) = &mut signature.type_parameters { - visitor.visit_ts_type_parameter_declaration(parameters); - } - - if let Some(annotation) = &mut signature.return_type { - visitor.visit_ts_type_annotation(annotation); - } - } - - pub fn walk_ts_type_query_mut<'a, V: VisitMut<'a>>(visitor: &mut V, ty: &mut TSTypeQuery<'a>) { - let kind = AstType::TSTypeQuery; - visitor.enter_node(kind); - match &mut ty.expr_name { - name @ match_ts_type_name!(TSTypeQueryExprName) => { - visitor.visit_ts_type_name(name.to_ts_type_name_mut()); - } - TSTypeQueryExprName::TSImportType(import) => visitor.visit_ts_import_type(import), - } - if let Some(type_parameters) = &mut ty.type_parameters { - visitor.visit_ts_type_parameter_instantiation(type_parameters); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_import_type_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - ty: &mut TSImportType<'a>, - ) { - let kind = AstType::TSImportType; - visitor.enter_node(kind); - visitor.visit_ts_type(&mut ty.parameter); - if let Some(name) = &mut ty.qualifier { - visitor.visit_ts_type_name(name); - } - if let Some(attrs) = &mut ty.attributes { - visitor.visit_ts_import_attributes(attrs); - } - if let Some(type_parameter) = &mut ty.type_parameters { - visitor.visit_ts_type_parameter_instantiation(type_parameter); - } - visitor.leave_node(kind); - } - - pub fn walk_ts_import_attributes_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - attributes: &mut TSImportAttributes<'a>, - ) { - for element in attributes.elements.iter_mut() { - visitor.visit_ts_import_attribute(element); - } - } - - pub fn walk_ts_import_attribute_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - attribute: &mut TSImportAttribute<'a>, - ) { - visitor.visit_ts_import_attribute_name(&mut attribute.name); - visitor.visit_expression(&mut attribute.value); - } - - pub fn walk_ts_import_attribute_name_mut<'a, V: VisitMut<'a>>( - visitor: &mut V, - name: &mut TSImportAttributeName<'a>, - ) { - match name { - TSImportAttributeName::Identifier(ident) => visitor.visit_identifier_name(ident), - TSImportAttributeName::StringLiteral(ident) => visitor.visit_string_literal(ident), - } - } -} diff --git a/crates/oxc_ast_macros/src/lib.rs b/crates/oxc_ast_macros/src/lib.rs index 37154f9e5387..5b3dae9d0496 100644 --- a/crates/oxc_ast_macros/src/lib.rs +++ b/crates/oxc_ast_macros/src/lib.rs @@ -22,7 +22,7 @@ pub fn visited_node(_args: TokenStream, input: TokenStream) -> TokenStream { /// Dummy derive macro for a non-existent trait `VisitedNode`. /// /// Does not generate any code, only purpose is to allow using `#[scope]` attr in the type def. -#[proc_macro_derive(VisitedNode, attributes(scope))] +#[proc_macro_derive(VisitedNode, attributes(span, scope, visit, visit_as, visit_args))] pub fn visited_node_derive(_item: TokenStream) -> TokenStream { TokenStream::new() } diff --git a/crates/oxc_codegen/src/gen.rs b/crates/oxc_codegen/src/gen.rs index 26d2a278de32..0dcc8a590a44 100644 --- a/crates/oxc_codegen/src/gen.rs +++ b/crates/oxc_codegen/src/gen.rs @@ -2994,6 +2994,9 @@ impl<'a, const MINIFY: bool> Gen for TSLiteral<'a> { impl<'a, const MINIFY: bool> Gen for TSTypeParameter<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { + if self.r#const { + p.print_str(b"const "); + } self.name.gen(p, ctx); if let Some(constraint) = &self.constraint { p.print_str(b" extends "); @@ -3073,6 +3076,9 @@ impl<'a, const MINIFY: bool> Gen for TSSignature<'a> { } } Self::TSCallSignatureDeclaration(signature) => { + if let Some(type_parameters) = signature.type_parameters.as_ref() { + type_parameters.gen(p, ctx); + } p.print_str(b"("); if let Some(this_param) = &signature.this_param { this_param.gen(p, ctx); diff --git a/crates/oxc_codegen/tests/mod.rs b/crates/oxc_codegen/tests/mod.rs index ba8742becf6e..f834ac8e8d22 100644 --- a/crates/oxc_codegen/tests/mod.rs +++ b/crates/oxc_codegen/tests/mod.rs @@ -199,6 +199,8 @@ fn typescript() { "class A {\n\treadonly type = 'frame';\n}\n", false, ); + test_ts("let foo: { (t: T): void }", "let foo: {(t: T): void};\n", false); + test_ts("function (){}", "function() {}\n", false); } fn test_comment_helper(source_text: &str, expected: &str) { diff --git a/crates/oxc_isolated_declarations/src/class.rs b/crates/oxc_isolated_declarations/src/class.rs index 792bbbca7bcc..cadaa08d57cc 100644 --- a/crates/oxc_isolated_declarations/src/class.rs +++ b/crates/oxc_isolated_declarations/src/class.rs @@ -66,7 +66,11 @@ impl<'a> IsolatedDeclarations<'a> { .value .as_ref() .and_then(|expr| { - let ts_type = self.infer_type_from_expression(expr); + let ts_type = if property.readonly { + self.transform_expression_to_ts_type(expr) + } else { + self.infer_type_from_expression(expr) + }; if ts_type.is_none() { self.error(property_must_have_explicit_type(property.key.span())); } @@ -76,6 +80,9 @@ impl<'a> IsolatedDeclarations<'a> { }) }; + // TODO if inferred type_annotations is TSLiteral, it should stand as value, + // so `field = 'string'` remain `field = 'string'` instead of `field: 'string'` + self.ast.class_property( property.r#type, property.span, @@ -231,7 +238,7 @@ impl<'a> IsolatedDeclarations<'a> { ) -> oxc_allocator::Vec<'a, ClassElement<'a>> { let mut elements = self.ast.new_vec(); for (index, param) in function.params.items.iter().enumerate() { - if param.accessibility.is_some() { + if param.accessibility.is_some() || param.readonly { // transformed params will definitely have type annotation let type_annotation = self.ast.copy(¶ms.items[index].pattern.type_annotation); if let Some(new_element) = @@ -329,7 +336,7 @@ impl<'a> IsolatedDeclarations<'a> { match element { ClassElement::StaticBlock(_) => {} ClassElement::MethodDefinition(ref method) => { - if method.value.body.is_none() { + if !method.r#type.is_abstract() && method.value.body.is_none() { is_function_overloads = true; } else if is_function_overloads { // Skip implementation of function overloads diff --git a/crates/oxc_isolated_declarations/src/declaration.rs b/crates/oxc_isolated_declarations/src/declaration.rs index cfc229125401..8c0307326914 100644 --- a/crates/oxc_isolated_declarations/src/declaration.rs +++ b/crates/oxc_isolated_declarations/src/declaration.rs @@ -49,13 +49,11 @@ impl<'a> IsolatedDeclarations<'a> { check_binding: bool, ) -> Option> { if decl.id.kind.is_destructuring_pattern() { - if check_binding { - decl.id.bound_names(&mut |id| { - if self.scope.has_reference(&id.name) { - self.error(binding_element_export(id.span)); - } - }); - } + decl.id.bound_names(&mut |id| { + if !check_binding || self.scope.has_reference(&id.name) { + self.error(binding_element_export(id.span)); + } + }); return None; } diff --git a/crates/oxc_isolated_declarations/src/function.rs b/crates/oxc_isolated_declarations/src/function.rs index 12c7278f6b99..bb581f3e30aa 100644 --- a/crates/oxc_isolated_declarations/src/function.rs +++ b/crates/oxc_isolated_declarations/src/function.rs @@ -106,14 +106,7 @@ impl<'a> IsolatedDeclarations<'a> { ); } - Some(self.ast.formal_parameter( - param.span, - pattern, - None, - param.readonly, - false, - self.ast.new_vec(), - )) + Some(self.ast.formal_parameter(param.span, pattern, None, false, false, self.ast.new_vec())) } pub fn transform_formal_parameters( diff --git a/crates/oxc_isolated_declarations/src/lib.rs b/crates/oxc_isolated_declarations/src/lib.rs index 9799618bbdf1..187b0c09d817 100644 --- a/crates/oxc_isolated_declarations/src/lib.rs +++ b/crates/oxc_isolated_declarations/src/lib.rs @@ -317,7 +317,7 @@ impl<'a> IsolatedDeclarations<'a> { } } - if last_transformed_len == transformed_indexes.len() { + if !transformed_indexes.is_empty() && last_transformed_len == transformed_indexes.len() { need_empty_export_marker = false; } diff --git a/crates/oxc_isolated_declarations/src/return_type.rs b/crates/oxc_isolated_declarations/src/return_type.rs index c953cdc5d16e..c5fc3f7c721e 100644 --- a/crates/oxc_isolated_declarations/src/return_type.rs +++ b/crates/oxc_isolated_declarations/src/return_type.rs @@ -138,7 +138,7 @@ impl<'a> Visit<'a> for FunctionReturnType<'a> { // We don't care about nested functions } - fn visit_arrow_expression(&mut self, _expr: &ArrowFunctionExpression<'a>) { + fn visit_arrow_function_expression(&mut self, _expr: &ArrowFunctionExpression<'a>) { // We don't care about nested functions } diff --git a/crates/oxc_isolated_declarations/src/scope.rs b/crates/oxc_isolated_declarations/src/scope.rs index a68951fd9bf1..94a347ca503d 100644 --- a/crates/oxc_isolated_declarations/src/scope.rs +++ b/crates/oxc_isolated_declarations/src/scope.rs @@ -209,8 +209,8 @@ impl<'a> Visit<'a> for ScopeTree<'a> { } } - fn visit_arrow_expression(&mut self, expr: &ArrowFunctionExpression<'a>) { - walk_arrow_expression(self, expr); + fn visit_arrow_function_expression(&mut self, expr: &ArrowFunctionExpression<'a>) { + walk_arrow_function_expression(self, expr); if expr.type_parameters.is_some() { self.leave_scope(); } diff --git a/crates/oxc_isolated_declarations/tests/fixtures/class.ts b/crates/oxc_isolated_declarations/tests/fixtures/class.ts index 2255754d7a8e..ae8b2713f155 100644 --- a/crates/oxc_isolated_declarations/tests/fixtures/class.ts +++ b/crates/oxc_isolated_declarations/tests/fixtures/class.ts @@ -6,4 +6,27 @@ export class Bar { public constructor(a: number = 0) {} } -export class Zoo { foo(f: F): F { return f } } \ No newline at end of file +export class Zoo { + foo(f: F): F { + return f; + } +} + +export abstract class Qux { + abstract foo(): void; + bar(): void {} + baz(): void {} +} + +export class Baz { + readonly prop1 = 'some string'; + prop2 = 'another string'; +} + +export class Boo { + constructor( + public readonly prop: number = 0, + private readonly prop2: number = 1, + readonly prop3: number = 1, + ) {} +} diff --git a/crates/oxc_isolated_declarations/tests/fixtures/empty-export2.ts b/crates/oxc_isolated_declarations/tests/fixtures/empty-export2.ts new file mode 100644 index 000000000000..17abd44386b7 --- /dev/null +++ b/crates/oxc_isolated_declarations/tests/fixtures/empty-export2.ts @@ -0,0 +1 @@ +import * as a from "mod"; \ No newline at end of file diff --git a/crates/oxc_isolated_declarations/tests/fixtures/non-exported-binding-elements.ts b/crates/oxc_isolated_declarations/tests/fixtures/non-exported-binding-elements.ts index 0e41ea05a2fc..22f6d6a8021f 100644 --- a/crates/oxc_isolated_declarations/tests/fixtures/non-exported-binding-elements.ts +++ b/crates/oxc_isolated_declarations/tests/fixtures/non-exported-binding-elements.ts @@ -7,4 +7,6 @@ export function foo(): number { // Incorrect const { c, d } = { c: 1, d: 2 }; const [ e ] = [4]; -export { c, d, e } \ No newline at end of file +export { c, d, e } + +export const { f, g } = { f: 5, g: 6 }; \ No newline at end of file diff --git a/crates/oxc_isolated_declarations/tests/snapshots/class.snap b/crates/oxc_isolated_declarations/tests/snapshots/class.snap index bb684775b7b2..5a598fed7d50 100644 --- a/crates/oxc_isolated_declarations/tests/snapshots/class.snap +++ b/crates/oxc_isolated_declarations/tests/snapshots/class.snap @@ -13,3 +13,18 @@ export declare class Bar { export declare class Zoo { foo(f: F): F; } +export declare abstract class Qux { + abstract foo(): void; + bar(): void; + baz(): void; +} +export declare class Baz { + readonly prop1: 'some string'; + prop2: string; +} +export declare class Boo { + readonly prop: number; + private readonly prop2: number; + readonly prop3: number; + constructor(prop?: number, prop2?: number, prop3?: number); +} diff --git a/crates/oxc_isolated_declarations/tests/snapshots/empty-export2.snap b/crates/oxc_isolated_declarations/tests/snapshots/empty-export2.snap new file mode 100644 index 000000000000..8092831a17fa --- /dev/null +++ b/crates/oxc_isolated_declarations/tests/snapshots/empty-export2.snap @@ -0,0 +1,7 @@ +--- +source: crates/oxc_isolated_declarations/tests/mod.rs +input_file: crates/oxc_isolated_declarations/tests/fixtures/empty-export2.ts +--- +==================== .D.TS ==================== + +export {}; diff --git a/crates/oxc_isolated_declarations/tests/snapshots/non-exported-binding-elements.snap b/crates/oxc_isolated_declarations/tests/snapshots/non-exported-binding-elements.snap index 50d585442bee..53339fc66da7 100644 --- a/crates/oxc_isolated_declarations/tests/snapshots/non-exported-binding-elements.snap +++ b/crates/oxc_isolated_declarations/tests/snapshots/non-exported-binding-elements.snap @@ -6,10 +6,27 @@ input_file: crates/oxc_isolated_declarations/tests/fixtures/non-exported-binding export declare function foo(): number; export { c, d, e }; +export declare const; ==================== Errors ==================== + x TS9019: Binding elements can't be exported directly with + | --isolatedDeclarations. + ,-[12:16] + 11 | + 12 | export const { f, g } = { f: 5, g: 6 }; + : ^ + `---- + + x TS9019: Binding elements can't be exported directly with + | --isolatedDeclarations. + ,-[12:19] + 11 | + 12 | export const { f, g } = { f: 5, g: 6 }; + : ^ + `---- + x TS9019: Binding elements can't be exported directly with | --isolatedDeclarations. ,-[8:9] diff --git a/crates/oxc_linter/CHANGELOG.md b/crates/oxc_linter/CHANGELOG.md index 32b78022fc43..b9b93e5194e3 100644 --- a/crates/oxc_linter/CHANGELOG.md +++ b/crates/oxc_linter/CHANGELOG.md @@ -4,6 +4,20 @@ All notable changes to this package will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project does not adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) until v1.0.0. +## [0.5.2] - 2024-07-02 + +### Features + +- b257d53 linter: Support report `@typescript-eslint/consistent-type-imports` (#3895) (mysteryven) +- 2114475 linter: Implement @typescript-eslint/no-dynamic-delete (#3971) (kaykdm) +- 10a3c9a linter/eslint-plugin-react: Implement no-set-state (#3975) (Jelle van der Waa) + +### Bug Fixes + +- 432d6d9 linter: Find disabled directives using the message's `Span`. (#4010) (rzvxa) +- dbbb6fc linter: Global variable check should always check builtin variables (#3973) (Boshen) + + ## [0.5.1] - 2024-06-29 ### Features diff --git a/crates/oxc_linter/Cargo.toml b/crates/oxc_linter/Cargo.toml index a8a4e0feb690..18badc952352 100644 --- a/crates/oxc_linter/Cargo.toml +++ b/crates/oxc_linter/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "oxc_linter" -version = "0.5.1" +version = "0.5.2" publish = false authors.workspace = true description.workspace = true diff --git a/crates/oxc_linter/src/context.rs b/crates/oxc_linter/src/context.rs index 40657f50d638..5064dcc7407f 100644 --- a/crates/oxc_linter/src/context.rs +++ b/crates/oxc_linter/src/context.rs @@ -3,7 +3,7 @@ use std::{cell::RefCell, path::Path, rc::Rc, sync::Arc}; use oxc_cfg::ControlFlowGraph; use oxc_diagnostics::{OxcDiagnostic, Severity}; use oxc_semantic::{AstNodes, JSDocFinder, ScopeTree, Semantic, SymbolTable}; -use oxc_span::{SourceType, Span}; +use oxc_span::{GetSpan, SourceType, Span}; use oxc_syntax::module_record::ModuleRecord; use crate::{ @@ -157,7 +157,7 @@ impl<'a> LintContext<'a> { } fn add_diagnostic(&self, message: Message<'a>) { - if !self.disable_directives.contains(self.current_rule_name, message.start()) { + if !self.disable_directives.contains(self.current_rule_name, message.span()) { let mut message = message; if message.error.severity != self.severity { message.error = message.error.with_severity(self.severity); diff --git a/crates/oxc_linter/src/disable_directives.rs b/crates/oxc_linter/src/disable_directives.rs index 46d164820db8..d3ea039f813e 100644 --- a/crates/oxc_linter/src/disable_directives.rs +++ b/crates/oxc_linter/src/disable_directives.rs @@ -27,8 +27,8 @@ pub struct DisableDirectives<'a> { } impl<'a> DisableDirectives<'a> { - pub fn contains(&self, rule_name: &'static str, start: u32) -> bool { - self.intervals.find(start, start + 1).any(|interval| { + pub fn contains(&self, rule_name: &'static str, span: Span) -> bool { + self.intervals.find(span.start, span.end).any(|interval| { interval.val == DisabledRule::All // Our rule name currently does not contain the prefix. // For example, this will match `@typescript-eslint/no-var-requires` given diff --git a/crates/oxc_linter/src/fixer.rs b/crates/oxc_linter/src/fixer.rs index 9ce5373eab0c..40e242f00459 100644 --- a/crates/oxc_linter/src/fixer.rs +++ b/crates/oxc_linter/src/fixer.rs @@ -189,15 +189,24 @@ impl<'a> Message<'a> { Self { error, start, end, fix, fixed: false } } + #[inline] pub fn start(&self) -> u32 { self.start } + #[inline] pub fn end(&self) -> u32 { self.end } } +impl<'a> GetSpan for Message<'a> { + #[inline] + fn span(&self) -> Span { + Span::new(self.start(), self.end()) + } +} + /// The fixer of the code. /// Note that our parser has handled the BOM, so we don't need to port the BOM test cases from `ESLint`. pub struct Fixer<'a> { diff --git a/crates/oxc_linter/src/rules/eslint/require_await.rs b/crates/oxc_linter/src/rules/eslint/require_await.rs index 6272687c2e0e..d7e13ab0e3ab 100644 --- a/crates/oxc_linter/src/rules/eslint/require_await.rs +++ b/crates/oxc_linter/src/rules/eslint/require_await.rs @@ -103,7 +103,7 @@ impl<'a> Visit<'a> for AwaitFinder { } } - fn visit_arrow_expression(&mut self, _expr: &ArrowFunctionExpression<'a>) {} + fn visit_arrow_function_expression(&mut self, _expr: &ArrowFunctionExpression<'a>) {} fn visit_function(&mut self, _func: &Function<'a>, _flags: Option) {} } diff --git a/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs b/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs index 6cc94539c15d..820292f54e6a 100644 --- a/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs +++ b/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs @@ -58,7 +58,13 @@ impl Rule for NoEmptyFile { return; } - ctx.diagnostic(no_empty_file_diagnostic(Span::new(0, 0))); + let mut span = program.span; + // only show diagnostic for the first 100 characters to avoid huge diagnostic messages with + // empty programs containing a bunch of comments. + // NOTE: if the enable/disable directives come after the first 100 characters they won't be + // respected by this diagnostic. + span.end = std::cmp::min(span.end, 100); + ctx.diagnostic(no_empty_file_diagnostic(span)); } } @@ -104,6 +110,7 @@ fn test() { r"[]", r"(() => {})()", "(() => {})();", + "/* eslint-disable no-empty-file */", ]; let fail = vec![ diff --git a/crates/oxc_linter/src/snapshots/no_empty_file.snap b/crates/oxc_linter/src/snapshots/no_empty_file.snap index c27c2bf20b90..7906d01f45d7 100644 --- a/crates/oxc_linter/src/snapshots/no_empty_file.snap +++ b/crates/oxc_linter/src/snapshots/no_empty_file.snap @@ -9,141 +9,140 @@ source: crates/oxc_linter/src/tester.rs ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ - · ▲ + · ─ ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ - · ▲ + · ──── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ - · ▲ + · ─ ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 0 │ - · ▲ + · ─ ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ - · ▲ + · ─ ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] - 1 │ - · ▲ - 2 │ - 3 │ + 1 │ ╭─▶ + 2 │ │ + 3 │ ╰─▶ ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ // comment - · ▲ + · ────────── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ /* comment */ - · ▲ + · ───────────── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ #!/usr/bin/env node - · ▲ + · ─────────────────── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ 'use asm'; - · ▲ + · ────────── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ 'use strict'; - · ▲ + · ───────────── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ "use strict" - · ▲ + · ──────────── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ "" - · ▲ + · ── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ ; - · ▲ + · ─ ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ ;; - · ▲ + · ── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ {} - · ▲ + · ── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ {;;} - · ▲ + · ──── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ {{}} - · ▲ + · ──── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ ""; - · ▲ + · ─── ╰──── help: Delete this file or add some code to it. ⚠ eslint-plugin-unicorn(no-empty-file): Empty files are not allowed. ╭─[no_empty_file.tsx:1:1] 1 │ "use strict"; - · ▲ + · ───────────── ╰──── help: Delete this file or add some code to it. diff --git a/crates/oxc_minifier/src/ast_passes/remove_dead_code.rs b/crates/oxc_minifier/src/ast_passes/remove_dead_code.rs index ce719abe791d..9115e0ac1eca 100644 --- a/crates/oxc_minifier/src/ast_passes/remove_dead_code.rs +++ b/crates/oxc_minifier/src/ast_passes/remove_dead_code.rs @@ -59,6 +59,6 @@ impl<'a> VisitMut<'a> for RemoveDeadCode<'a> { fn visit_statement(&mut self, stmt: &mut Statement<'a>) { self.remove_if(stmt); self.remove_conditional(stmt); - walk_mut::walk_statement_mut(self, stmt); + walk_mut::walk_statement(self, stmt); } } diff --git a/crates/oxc_minifier/src/ast_passes/remove_parens.rs b/crates/oxc_minifier/src/ast_passes/remove_parens.rs index 3f59a63a2f50..9b856718dbe9 100644 --- a/crates/oxc_minifier/src/ast_passes/remove_parens.rs +++ b/crates/oxc_minifier/src/ast_passes/remove_parens.rs @@ -26,11 +26,11 @@ impl<'a> RemoveParens<'a> { impl<'a> VisitMut<'a> for RemoveParens<'a> { fn visit_statements(&mut self, stmts: &mut Vec<'a, Statement<'a>>) { stmts.retain(|stmt| !matches!(stmt, Statement::EmptyStatement(_))); - walk_mut::walk_statements_mut(self, stmts); + walk_mut::walk_statements(self, stmts); } fn visit_expression(&mut self, expr: &mut Expression<'a>) { self.strip_parenthesized_expression(expr); - walk_mut::walk_expression_mut(self, expr); + walk_mut::walk_expression(self, expr); } } diff --git a/crates/oxc_minifier/src/ast_passes/replace_global_defines.rs b/crates/oxc_minifier/src/ast_passes/replace_global_defines.rs index ab8a197505cf..b65696917305 100644 --- a/crates/oxc_minifier/src/ast_passes/replace_global_defines.rs +++ b/crates/oxc_minifier/src/ast_passes/replace_global_defines.rs @@ -99,6 +99,6 @@ impl<'a> ReplaceGlobalDefines<'a> { impl<'a> VisitMut<'a> for ReplaceGlobalDefines<'a> { fn visit_expression(&mut self, expr: &mut Expression<'a>) { self.replace_identifier_defines(expr); - walk_mut::walk_expression_mut(self, expr); + walk_mut::walk_expression(self, expr); } } diff --git a/crates/oxc_minifier/src/compressor/mod.rs b/crates/oxc_minifier/src/compressor/mod.rs index 793982e06783..1d30a993a215 100644 --- a/crates/oxc_minifier/src/compressor/mod.rs +++ b/crates/oxc_minifier/src/compressor/mod.rs @@ -6,10 +6,7 @@ mod options; mod util; use oxc_allocator::{Allocator, Vec}; -use oxc_ast::visit::walk_mut::{ - walk_binary_expression_mut, walk_expression_mut, walk_return_statement_mut, walk_statement_mut, - walk_statements_mut, -}; +use oxc_ast::visit::walk_mut; #[allow(clippy::wildcard_imports)] use oxc_ast::{ast::*, AstBuilder, VisitMut}; use oxc_span::Span; @@ -323,18 +320,18 @@ impl<'a> VisitMut<'a> for Compressor<'a> { self.join_vars(stmts); } - walk_statements_mut(self, stmts); + walk_mut::walk_statements(self, stmts); } fn visit_statement(&mut self, stmt: &mut Statement<'a>) { self.compress_block(stmt); self.compress_while(stmt); self.fold_condition(stmt); - walk_statement_mut(self, stmt); + walk_mut::walk_statement(self, stmt); } fn visit_return_statement(&mut self, stmt: &mut ReturnStatement<'a>) { - walk_return_statement_mut(self, stmt); + walk_mut::walk_return_statement(self, stmt); // We may fold `void 1` to `void 0`, so compress it after visiting self.compress_return_statement(stmt); } @@ -347,7 +344,7 @@ impl<'a> VisitMut<'a> for Compressor<'a> { } fn visit_expression(&mut self, expr: &mut Expression<'a>) { - walk_expression_mut(self, expr); + walk_mut::walk_expression(self, expr); self.compress_console(expr); self.fold_expression(expr); if !self.compress_undefined(expr) { @@ -356,7 +353,7 @@ impl<'a> VisitMut<'a> for Compressor<'a> { } fn visit_binary_expression(&mut self, expr: &mut BinaryExpression<'a>) { - walk_binary_expression_mut(self, expr); + walk_mut::walk_binary_expression(self, expr); self.compress_typeof_undefined(expr); } } diff --git a/crates/oxc_parser/src/cursor.rs b/crates/oxc_parser/src/cursor.rs index 45650dda2112..9339200aeaca 100644 --- a/crates/oxc_parser/src/cursor.rs +++ b/crates/oxc_parser/src/cursor.rs @@ -1,8 +1,9 @@ //! Code related to navigating `Token`s from the lexer +use oxc_allocator::Vec; use oxc_ast::ast::{Decorator, RegExpFlags}; use oxc_diagnostics::Result; -use oxc_span::Span; +use oxc_span::{GetSpan, Span}; use crate::{ diagnostics, @@ -330,7 +331,7 @@ impl<'a> ParserImpl<'a> { result } - pub(crate) fn consume_decorators(&mut self) -> oxc_allocator::Vec<'a, Decorator<'a>> { + pub(crate) fn consume_decorators(&mut self) -> Vec<'a, Decorator<'a>> { let decorators = std::mem::take(&mut self.state.decorators); self.ast.new_vec_from_iter(decorators) } @@ -340,7 +341,7 @@ impl<'a> ParserImpl<'a> { open: Kind, close: Kind, f: F, - ) -> Result> + ) -> Result> where F: Fn(&mut Self) -> Result>, { @@ -367,7 +368,7 @@ impl<'a> ParserImpl<'a> { separator: Kind, trailing_separator: bool, f: F, - ) -> Result> + ) -> Result> where F: Fn(&mut Self) -> Result, { @@ -393,4 +394,43 @@ impl<'a> ParserImpl<'a> { } Ok(list) } + + pub(crate) fn parse_delimited_list_with_rest( + &mut self, + close: Kind, + parse_element: E, + parse_rest: R, + ) -> Result<(Vec<'a, A>, Option)> + where + E: Fn(&mut Self) -> Result, + R: Fn(&mut Self) -> Result, + B: GetSpan, + { + let mut list = self.ast.new_vec(); + let mut rest = None; + let mut first = true; + loop { + let kind = self.cur_kind(); + if kind == close || kind == Kind::Eof { + break; + } + if first { + first = false; + } else { + self.expect(Kind::Comma)?; + if self.at(close) { + break; + } + } + + if self.at(Kind::Dot3) { + if let Some(r) = rest.replace(parse_rest(self)?) { + self.error(diagnostics::binding_rest_element_last(r.span())); + } + } else { + list.push(parse_element(self)?); + } + } + Ok((list, rest)) + } } diff --git a/crates/oxc_parser/src/js/binding.rs b/crates/oxc_parser/src/js/binding.rs index 6e6ccd9f1a4c..4594b39a7827 100644 --- a/crates/oxc_parser/src/js/binding.rs +++ b/crates/oxc_parser/src/js/binding.rs @@ -1,10 +1,8 @@ -use oxc_allocator::Box; use oxc_ast::ast::*; use oxc_diagnostics::Result; -use oxc_span::Span; +use oxc_span::{GetSpan, Span}; -use super::list::{ArrayPatternList, ObjectPatternProperties}; -use crate::{diagnostics, lexer::Kind, list::SeparatedList, Context, ParserImpl}; +use crate::{diagnostics, lexer::Kind, Context, ParserImpl}; impl<'a> ParserImpl<'a> { /// `BindingElement` @@ -46,19 +44,60 @@ impl<'a> ParserImpl<'a> { /// Section 14.3.3 Object Binding Pattern fn parse_object_binding_pattern(&mut self) -> Result> { let span = self.start_span(); - let props = ObjectPatternProperties::parse(self)?; - Ok(self.ast.object_pattern(self.end_span(span), props.elements, props.rest)) + self.expect(Kind::LCurly)?; + let (list, rest) = self.parse_delimited_list_with_rest( + Kind::RCurly, + Self::parse_binding_property, + Self::parse_rest_binding, + )?; + if let Some(rest) = &rest { + if !matches!(&rest.argument.kind, BindingPatternKind::BindingIdentifier(_)) { + return Err(diagnostics::invalid_binding_rest_element(rest.argument.span())); + } + } + self.expect(Kind::RCurly)?; + Ok(self.ast.object_pattern(self.end_span(span), list, rest.map(|r| self.ast.alloc(r)))) } /// Section 14.3.3 Array Binding Pattern fn parse_array_binding_pattern(&mut self) -> Result> { let span = self.start_span(); - let list = ArrayPatternList::parse(self)?; - Ok(self.ast.array_pattern(self.end_span(span), list.elements, list.rest)) + self.expect(Kind::LBrack)?; + let (list, rest) = self.parse_delimited_list_with_rest( + Kind::RBrack, + Self::parse_array_binding_element, + Self::parse_rest_binding, + )?; + self.expect(Kind::RBrack)?; + Ok(self.ast.array_pattern(self.end_span(span), list, rest.map(|r| self.ast.alloc(r)))) + } + + fn parse_array_binding_element(&mut self) -> Result>> { + if self.at(Kind::Comma) { + Ok(None) + } else { + self.parse_binding_pattern_with_initializer().map(Some) + } + } + + fn parse_rest_binding(&mut self) -> Result> { + // self.eat_decorators()?; + let elem = self.parse_rest_element()?; + if self.at(Kind::Comma) { + if matches!(self.peek_kind(), Kind::RCurly | Kind::RBrack) { + let span = self.cur_token().span(); + self.bump_any(); + self.error(diagnostics::binding_rest_element_trailing_comma(span)); + } + if !self.ctx.has_ambient() { + self.error(diagnostics::binding_rest_element_last(elem.span)); + } + } + Ok(elem) } /// Section 14.3.3 Binding Rest Property - pub(super) fn parse_rest_element(&mut self) -> Result>> { + pub(super) fn parse_rest_element(&mut self) -> Result> { let span = self.start_span(); self.bump_any(); // advance `...` let init_span = self.start_span(); @@ -73,22 +112,12 @@ impl<'a> ParserImpl<'a> { // The span is not extended to its type_annotation let type_annotation = self.parse_ts_type_annotation()?; let pattern = self.ast.binding_pattern(kind, type_annotation, false); - // Rest element does not allow `= initializer`, . + // Rest element does not allow `= initializer` let argument = self .context(Context::In, Context::empty(), |p| p.parse_initializer(init_span, pattern))?; let span = self.end_span(span); - if self.at(Kind::Comma) { - if self.peek_at(Kind::RBrack) { - self.error(diagnostics::binding_rest_element_trailing_comma( - self.cur_token().span(), - )); - } else if !self.ctx.has_ambient() { - self.error(diagnostics::binding_rest_element_last(span)); - } - } - - Ok(self.ast.rest_element(span, argument)) + Ok(BindingRestElement { span, argument }) } /// `BindingProperty`[Yield, Await] : diff --git a/crates/oxc_parser/src/js/function.rs b/crates/oxc_parser/src/js/function.rs index de82711a61c8..03cebbf62c20 100644 --- a/crates/oxc_parser/src/js/function.rs +++ b/crates/oxc_parser/src/js/function.rs @@ -5,11 +5,10 @@ use oxc_ast::ast::*; use oxc_diagnostics::Result; use oxc_span::Span; -use super::{list::FormalParameterList, FunctionKind}; +use super::FunctionKind; use crate::{ diagnostics, lexer::Kind, - list::SeparatedList, modifiers::{ModifierFlags, ModifierKind, Modifiers}, Context, ParserImpl, StatementContext, }; @@ -49,13 +48,74 @@ impl<'a> ParserImpl<'a> { params_kind: FormalParameterKind, ) -> Result<(Option>, 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; + self.expect(Kind::LParen)?; + let this_param = if self.ts_enabled() && self.at(Kind::This) { + let param = self.parse_ts_this_parameter()?; + if !self.at(Kind::RParen) { + self.expect(Kind::Comma)?; + } + Some(param) + } else { + None + }; + let (list, rest) = self.parse_delimited_list_with_rest( + Kind::RParen, + Self::parse_formal_parameter, + Self::parse_rest_parameter, + )?; + self.expect(Kind::RParen)?; + let formal_parameters = self.ast.formal_parameters( + self.end_span(span), + params_kind, + list, + rest.map(|r| self.ast.alloc(r)), + ); Ok((this_param, formal_parameters)) } + fn parse_parameter_modifiers(&mut self) -> Modifiers<'a> { + let modifiers = self.parse_class_element_modifiers(true); + self.verify_modifiers( + &modifiers, + ModifierFlags::ACCESSIBILITY + .union(ModifierFlags::READONLY) + .union(ModifierFlags::OVERRIDE), + diagnostics::cannot_appear_on_a_parameter, + ); + modifiers + } + + fn parse_formal_parameter(&mut self) -> Result> { + let span = self.start_span(); + self.eat_decorators()?; + let modifiers = self.parse_parameter_modifiers(); + let pattern = self.parse_binding_pattern_with_initializer()?; + let decorators = self.consume_decorators(); + Ok(self.ast.formal_parameter( + self.end_span(span), + pattern, + modifiers.accessibility(), + modifiers.contains_readonly(), + modifiers.contains_override(), + decorators, + )) + } + + fn parse_rest_parameter(&mut self) -> Result> { + let element = self.parse_rest_element()?; + if self.at(Kind::Comma) { + if matches!(self.peek_kind(), Kind::RCurly | Kind::RBrack) { + let span = self.cur_token().span(); + self.bump_any(); + self.error(diagnostics::binding_rest_element_trailing_comma(span)); + } + if !self.ctx.has_ambient() { + self.error(diagnostics::rest_parameter_last(element.span)); + } + } + Ok(element) + } + pub(crate) fn parse_function( &mut self, span: Span, diff --git a/crates/oxc_parser/src/js/list.rs b/crates/oxc_parser/src/js/list.rs deleted file mode 100644 index 119f50b31259..000000000000 --- a/crates/oxc_parser/src/js/list.rs +++ /dev/null @@ -1,148 +0,0 @@ -use oxc_allocator::Vec; -use oxc_ast::ast::*; -use oxc_diagnostics::Result; -use oxc_span::GetSpan; - -use crate::{diagnostics, lexer::Kind, list::SeparatedList, modifiers::ModifierFlags, ParserImpl}; - -/// ObjectPattern.properties -pub struct ObjectPatternProperties<'a> { - pub elements: Vec<'a, BindingProperty<'a>>, - pub rest: Option>>, -} - -impl<'a> SeparatedList<'a> for ObjectPatternProperties<'a> { - fn new(p: &ParserImpl<'a>) -> Self { - Self { elements: p.ast.new_vec(), rest: None } - } - - fn open(&self) -> Kind { - Kind::LCurly - } - - fn close(&self) -> Kind { - Kind::RCurly - } - - fn parse_element(&mut self, p: &mut ParserImpl<'a>) -> Result<()> { - if p.cur_kind() == Kind::Dot3 { - let rest = p.parse_rest_element()?; - if !matches!(&rest.argument.kind, BindingPatternKind::BindingIdentifier(_)) { - p.error(diagnostics::invalid_binding_rest_element(rest.argument.span())); - } - if let Some(r) = self.rest.replace(rest) { - p.error(diagnostics::binding_rest_element_last(r.span)); - } - } else { - let prop = p.parse_binding_property()?; - self.elements.push(prop); - } - Ok(()) - } -} - -/// ArrayPattern.elements -pub struct ArrayPatternList<'a> { - pub elements: Vec<'a, Option>>, - pub rest: Option>>, -} - -impl<'a> SeparatedList<'a> for ArrayPatternList<'a> { - fn new(p: &ParserImpl<'a>) -> Self { - Self { elements: p.ast.new_vec(), rest: None } - } - - fn open(&self) -> Kind { - Kind::LBrack - } - - fn close(&self) -> Kind { - Kind::RBrack - } - - fn parse_element(&mut self, p: &mut ParserImpl<'a>) -> Result<()> { - match p.cur_kind() { - Kind::Comma => { - self.elements.push(None); - } - Kind::Dot3 => { - let rest = p.parse_rest_element()?; - if let Some(r) = self.rest.replace(rest) { - p.error(diagnostics::binding_rest_element_last(r.span)); - } - } - _ => { - let element = p.parse_binding_pattern_with_initializer()?; - self.elements.push(Some(element)); - } - } - Ok(()) - } -} - -/// Function Parameters -pub struct FormalParameterList<'a> { - pub elements: Vec<'a, FormalParameter<'a>>, - pub rest: Option>>, - pub this_param: Option>, -} - -impl<'a> SeparatedList<'a> for FormalParameterList<'a> { - fn new(p: &ParserImpl<'a>) -> Self { - Self { elements: p.ast.new_vec(), rest: None, this_param: None } - } - - fn open(&self) -> Kind { - Kind::LParen - } - - fn close(&self) -> Kind { - Kind::RParen - } - - // Section 15.1 Parameter Lists - fn parse_element(&mut self, p: &mut ParserImpl<'a>) -> Result<()> { - let span = p.start_span(); - p.eat_decorators()?; - - let modifiers = p.parse_class_element_modifiers(true); - let accessibility = modifiers.accessibility(); - let readonly = modifiers.contains_readonly(); - let r#override = modifiers.contains_override(); - p.verify_modifiers( - &modifiers, - ModifierFlags::ACCESSIBILITY - .union(ModifierFlags::READONLY) - .union(ModifierFlags::OVERRIDE), - diagnostics::cannot_appear_on_a_parameter, - ); - - match p.cur_kind() { - Kind::This if p.ts_enabled() => { - let this_parameter = p.parse_ts_this_parameter()?; - self.this_param.replace(this_parameter); - } - Kind::Dot3 => { - let rest = p.parse_rest_element()?; - if let Some(r) = self.rest.replace(rest) { - p.error(diagnostics::rest_parameter_last(r.span)); - } - } - _ => { - let pattern = p.parse_binding_pattern_with_initializer()?; - let decorators = p.consume_decorators(); - let formal_parameter = p.ast.formal_parameter( - p.end_span(span), - pattern, - accessibility, - readonly, - r#override, - decorators, - ); - self.elements.push(formal_parameter); - } - } - - Ok(()) - } -} diff --git a/crates/oxc_parser/src/js/mod.rs b/crates/oxc_parser/src/js/mod.rs index 27f4667bf48d..41133dab4586 100644 --- a/crates/oxc_parser/src/js/mod.rs +++ b/crates/oxc_parser/src/js/mod.rs @@ -3,7 +3,6 @@ #![allow(clippy::missing_errors_doc)] mod grammar; -pub mod list; mod arrow; mod binding; diff --git a/crates/oxc_parser/src/lib.rs b/crates/oxc_parser/src/lib.rs index 2fba591e8913..e30ba847c534 100644 --- a/crates/oxc_parser/src/lib.rs +++ b/crates/oxc_parser/src/lib.rs @@ -63,7 +63,6 @@ mod context; mod cursor; -mod list; mod modifiers; mod state; diff --git a/crates/oxc_parser/src/list.rs b/crates/oxc_parser/src/list.rs deleted file mode 100644 index 5d31b64d7f63..000000000000 --- a/crates/oxc_parser/src/list.rs +++ /dev/null @@ -1,49 +0,0 @@ -use oxc_diagnostics::Result; - -use crate::{lexer::Kind, ParserImpl}; - -pub trait SeparatedList<'a>: Sized { - fn new(p: &ParserImpl<'a>) -> Self; - - fn parse(p: &mut ParserImpl<'a>) -> Result { - let mut list = Self::new(p); - list.parse_list(p)?; - Ok(list) - } - - /// Open element, e.g.. `{` `[` `(` - fn open(&self) -> Kind; - - /// Close element, e.g.. `}` `]` `)` - fn close(&self) -> Kind; - - /// Separator element, e.g. `,` - fn separator(&self) -> Kind { - Kind::Comma - } - - fn parse_element(&mut self, p: &mut ParserImpl<'a>) -> Result<()>; - - /// Main entry point, parse the list - fn parse_list(&mut self, p: &mut ParserImpl<'a>) -> Result<()> { - p.expect(self.open())?; - - let mut first = true; - - while !p.at(self.close()) && !p.at(Kind::Eof) { - if first { - first = false; - } else { - p.expect(self.separator())?; - if p.at(self.close()) { - break; - } - } - - self.parse_element(p)?; - } - - p.expect(self.close())?; - Ok(()) - } -} diff --git a/crates/oxc_parser/src/ts/statement.rs b/crates/oxc_parser/src/ts/statement.rs index d9673bd7a833..23b2b9da9c67 100644 --- a/crates/oxc_parser/src/ts/statement.rs +++ b/crates/oxc_parser/src/ts/statement.rs @@ -439,12 +439,12 @@ impl<'a> ParserImpl<'a> { pub(crate) fn parse_ts_this_parameter(&mut self) -> Result> { let span = self.start_span(); - + self.parse_class_element_modifiers(true); + self.eat_decorators()?; let this = { let (span, name) = self.parse_identifier_kind(Kind::This); IdentifierName { span, name } }; - let type_annotation = self.parse_ts_type_annotation()?; Ok(self.ast.ts_this_parameter(self.end_span(span), this, type_annotation)) } diff --git a/crates/oxc_semantic/src/builder.rs b/crates/oxc_semantic/src/builder.rs index 3c0c4d8363df..357963f40ae7 100644 --- a/crates/oxc_semantic/src/builder.rs +++ b/crates/oxc_semantic/src/builder.rs @@ -1529,7 +1529,7 @@ impl<'a> Visit<'a> for SemanticBuilder<'a> { self.leave_scope(); } - fn visit_arrow_expression(&mut self, expr: &ArrowFunctionExpression<'a>) { + fn visit_arrow_function_expression(&mut self, expr: &ArrowFunctionExpression<'a>) { let kind = AstKind::ArrowFunctionExpression(self.alloc(expr)); self.enter_scope(ScopeFlags::Function | ScopeFlags::Arrow); expr.scope_id.set(Some(self.current_scope_id)); @@ -1577,14 +1577,14 @@ impl<'a> Visit<'a> for SemanticBuilder<'a> { self.leave_scope(); } - fn visit_enum(&mut self, decl: &TSEnumDeclaration<'a>) { + fn visit_ts_enum_declaration(&mut self, decl: &TSEnumDeclaration<'a>) { let kind = AstKind::TSEnumDeclaration(self.alloc(decl)); self.enter_node(kind); self.visit_binding_identifier(&decl.id); self.enter_scope(ScopeFlags::empty()); decl.scope_id.set(Some(self.current_scope_id)); for member in &decl.members { - self.visit_enum_member(member); + self.visit_ts_enum_member(member); } self.leave_scope(); self.leave_node(kind); diff --git a/crates/oxc_transformer/src/typescript/enum.rs b/crates/oxc_transformer/src/typescript/enum.rs index 637784eaf7ce..2375e763c2e4 100644 --- a/crates/oxc_transformer/src/typescript/enum.rs +++ b/crates/oxc_transformer/src/typescript/enum.rs @@ -598,7 +598,7 @@ impl<'a, 'b> VisitMut<'a> for IdentifierReferenceRename<'a, 'b> { if let Some(new_expr) = new_expr { *expr = new_expr; } else { - walk_mut::walk_expression_mut(self, expr); + walk_mut::walk_expression(self, expr); } } } diff --git a/crates/oxc_traverse/src/context/scoping.rs b/crates/oxc_traverse/src/context/scoping.rs index 0c6282a028db..b67a3adaa72e 100644 --- a/crates/oxc_traverse/src/context/scoping.rs +++ b/crates/oxc_traverse/src/context/scoping.rs @@ -565,11 +565,11 @@ impl<'a> Visit<'a> for ChildScopeCollector { self.scope_ids.push(block.scope_id.get().unwrap()); } - fn visit_arrow_expression(&mut self, expr: &ArrowFunctionExpression<'a>) { + fn visit_arrow_function_expression(&mut self, expr: &ArrowFunctionExpression<'a>) { self.scope_ids.push(expr.scope_id.get().unwrap()); } - fn visit_enum(&mut self, decl: &TSEnumDeclaration<'a>) { + fn visit_ts_enum_declaration(&mut self, decl: &TSEnumDeclaration<'a>) { self.scope_ids.push(decl.scope_id.get().unwrap()); } diff --git a/editors/vscode/package.json b/editors/vscode/package.json index cba82a7750b0..95428328685d 100644 --- a/editors/vscode/package.json +++ b/editors/vscode/package.json @@ -2,7 +2,7 @@ "name": "oxc-vscode", "description": "oxc vscode extension", "license": "MIT", - "version": "0.5.1", + "version": "0.5.2", "icon": "icon.png", "publisher": "oxc", "displayName": "Oxc", @@ -130,4 +130,4 @@ "vsce": { "dependencies": false } -} \ No newline at end of file +} diff --git a/npm/oxlint/package.json b/npm/oxlint/package.json index d7ad2f354efe..08d04129d0ea 100644 --- a/npm/oxlint/package.json +++ b/npm/oxlint/package.json @@ -1,6 +1,6 @@ { "name": "oxlint", - "version": "0.5.1", + "version": "0.5.2", "description": "Linter for the JavaScript Oxidation Compiler", "keywords": [], "author": "Boshen and oxc contributors", @@ -25,4 +25,4 @@ "configuration_schema.json", "README.md" ] -} \ No newline at end of file +} diff --git a/tasks/ast_codegen/Cargo.toml b/tasks/ast_codegen/Cargo.toml index 441d7db8d97a..012c27454bd2 100644 --- a/tasks/ast_codegen/Cargo.toml +++ b/tasks/ast_codegen/Cargo.toml @@ -30,3 +30,4 @@ serde = { workspace = true, features = ["derive"] } regex = { workspace = true } prettyplease = { workspace = true } lazy_static = { workspace = true } +convert_case = { workspace = true } diff --git a/tasks/ast_codegen/src/defs.rs b/tasks/ast_codegen/src/defs.rs index 1733d8e7503d..ad7b5cb69706 100644 --- a/tasks/ast_codegen/src/defs.rs +++ b/tasks/ast_codegen/src/defs.rs @@ -1,5 +1,5 @@ use super::{REnum, RStruct, RType}; -use crate::{schema::Inherit, TypeName}; +use crate::{schema::Inherit, util::TypeExt, TypeName}; use quote::ToTokens; use serde::Serialize; @@ -95,7 +95,7 @@ impl From<&Inherit> for EnumInheritDef { fn from(inherit: &Inherit) -> Self { match inherit { Inherit::Linked { super_, variants } => Self { - super_name: super_.into(), + super_name: super_.get_ident().as_ident().unwrap().to_string(), variants: variants.iter().map(Into::into).collect(), }, Inherit::Unlinked(_) => { diff --git a/tasks/ast_codegen/src/generators/ast_kind.rs b/tasks/ast_codegen/src/generators/ast_kind.rs index c0cea6da7647..837861eaf93a 100644 --- a/tasks/ast_codegen/src/generators/ast_kind.rs +++ b/tasks/ast_codegen/src/generators/ast_kind.rs @@ -2,13 +2,13 @@ use itertools::Itertools; use quote::quote; use syn::{parse_quote, Arm, Ident, Type, Variant}; -use crate::{schema::RType, CodegenCtx, Generator, GeneratorOutput}; +use crate::{schema::RType, util::TypeExt, CodegenCtx, Generator, GeneratorOutput, TypeRef}; use super::generated_header; pub struct AstKindGenerator; -const BLACK_LIST: [&str; 69] = [ +pub const BLACK_LIST: [&str; 69] = [ "Expression", "ObjectPropertyKind", "TemplateElement", @@ -84,13 +84,64 @@ pub fn blacklist((ident, _): &(Ident, Type)) -> bool { !BLACK_LIST.contains(&ident.to_string().as_str()) } -pub fn aliased_nodes() -> [(Ident, Type); 3] { +pub fn aliased_nodes() -> [(Ident, Type); 1] { use syn::parse_quote as pq; - [ - (pq!(FinallyClause), pq!(BlockStatement<'a>)), - (pq!(ClassHeritage), pq!(Expression<'a>)), - (pq!(ExpressionArrayElement), pq!(Expression<'a>)), - ] + [(pq!(ExpressionArrayElement), pq!(Expression<'a>))] +} + +pub fn process_types(ty: &TypeRef) -> Vec<(Ident, Type)> { + let aliases = match &*ty.borrow() { + RType::Enum(enum_) => enum_ + .item + .variants + .iter() + .filter_map(|it| { + it.attrs + .iter() + .find(|it| it.path().is_ident("visit_as")) + .map(|attr| (it, attr)) + .map(|(it, attr)| { + assert!( + it.fields.len() == 1, + "visit_as only supports single argument fields." + ); + let field = it.fields.iter().next().unwrap(); + let type_name = field.ty.get_ident().inner_ident(); + (attr.parse_args().unwrap(), parse_quote!(#type_name<'a>)) + }) + }) + .collect_vec(), + RType::Struct(struct_) => struct_ + .item + .fields + .iter() + .filter_map(|it| { + it.attrs + .iter() + .find(|it| it.path().is_ident("visit_as")) + .map(|attr| (it, attr)) + .map(|(field, attr)| { + let type_name = field.ty.get_ident().inner_ident(); + (attr.parse_args().unwrap(), parse_quote!(#type_name<'a>)) + }) + }) + .collect_vec(), + _ => panic!(), + }; + + Some(ty) + .into_iter() + .map(|kind| { + if let kind @ (RType::Enum(_) | RType::Struct(_)) = &*kind.borrow() { + let ident = kind.ident().unwrap().clone(); + let typ = kind.as_type().unwrap(); + (ident, typ) + } else { + panic!() + } + }) + .chain(aliases) + .collect() } impl Generator for AstKindGenerator { @@ -102,14 +153,11 @@ impl Generator for AstKindGenerator { let have_kinds: Vec<(Ident, Type)> = ctx .ty_table .iter() - .filter_map(|maybe_kind| match &*maybe_kind.borrow() { - kind @ (RType::Enum(_) | RType::Struct(_)) if kind.visitable() => { - let ident = kind.ident().unwrap().clone(); - let typ = kind.as_type().unwrap(); - Some((ident, typ)) - } - _ => None, - }) + .filter(|it| it.borrow().visitable()) + .filter( + |maybe_kind| matches!(&*maybe_kind.borrow(), kind @ (RType::Enum(_) | RType::Struct(_)) if kind.visitable()) + ) + .flat_map(process_types) .filter(blacklist) .chain(aliased_nodes()) .collect(); diff --git a/tasks/ast_codegen/src/generators/impl_get_span.rs b/tasks/ast_codegen/src/generators/impl_get_span.rs index 312f9020ac9a..adf83229cf47 100644 --- a/tasks/ast_codegen/src/generators/impl_get_span.rs +++ b/tasks/ast_codegen/src/generators/impl_get_span.rs @@ -15,23 +15,6 @@ use super::generated_header; pub struct ImplGetSpanGenerator; -const EDGE_CASES: [&str; 1] = ["BindingPattern"]; - -fn edge_case(it: &std::cell::Ref) -> bool { - !it.ident().is_some_and(|it| EDGE_CASES.contains(&it.to_string().as_str())) -} - -fn edge_case_impls() -> TokenStream { - quote! { - endl!(); - impl<'a> GetSpan for BindingPattern<'a> { - fn span(&self) -> Span { - self.kind.span() - } - } - } -} - impl Generator for ImplGetSpanGenerator { fn name(&self) -> &'static str { "ImplGetSpanGenerator" @@ -44,7 +27,6 @@ impl Generator for ImplGetSpanGenerator { .map(|it| it.borrow()) .filter(|it| it.visitable()) .filter(|it| matches!(&**it, RType::Enum(_) | RType::Struct(_))) - .filter(edge_case) .map(|kind| match &*kind { RType::Enum(it) => impl_enum(it), RType::Struct(it) => impl_struct(it), @@ -52,8 +34,6 @@ impl Generator for ImplGetSpanGenerator { }) .collect(); - let edge_impls = edge_case_impls(); - let header = generated_header!(); GeneratorOutput::One(quote! { @@ -65,9 +45,6 @@ impl Generator for ImplGetSpanGenerator { use oxc_span::{GetSpan, Span}; #(#impls)* - - #edge_impls - }) } } @@ -96,12 +73,20 @@ fn impl_enum(it @ REnum { item, .. }: &REnum) -> TokenStream { fn impl_struct(it @ RStruct { item, .. }: &RStruct) -> TokenStream { let typ = it.as_type(); let generics = &item.generics; + let inner_span_hint = + item.fields.iter().find(|it| it.attrs.iter().any(|a| a.path().is_ident("span"))); + let span = if let Some(span_field) = inner_span_hint { + let ident = span_field.ident.as_ref().unwrap(); + quote!(#ident.span()) + } else { + quote!(span) + }; quote! { endl!(); impl #generics GetSpan for #typ { #[inline] fn span(&self) -> Span { - self.span + self.#span } } } diff --git a/tasks/ast_codegen/src/generators/mod.rs b/tasks/ast_codegen/src/generators/mod.rs index 01959fc2a0c8..ab7113cf1502 100644 --- a/tasks/ast_codegen/src/generators/mod.rs +++ b/tasks/ast_codegen/src/generators/mod.rs @@ -1,6 +1,7 @@ mod ast; mod ast_kind; mod impl_get_span; +mod visit; /// Inserts a newline in the `TokenStream`. #[allow(unused)] @@ -14,8 +15,8 @@ macro_rules! endl { /// used outside and accepts expressions. /// Wraps the result of the given expression in `insert!({value here});` and outputs it as `TokenStream`. macro_rules! insert { - ($txt:expr) => {{ - let txt: &str = &*$txt; + ($fmt:literal $(, $args:expr)*) => {{ + let txt = format!($fmt, $($args)*); format!(r#"insert!("{}");"#, txt).parse::().unwrap() }}; } @@ -24,9 +25,8 @@ macro_rules! insert { macro_rules! generated_header { () => {{ let file = file!().replace("\\", "/"); - let edit_comment = $crate::generators::insert!(format!( - "// To edit this generated file you have to edit `{file}`" - )); + let edit_comment = + $crate::generators::insert!("// To edit this generated file you have to edit `{file}`"); // TODO add generation date, AST source hash, etc here. quote::quote! { insert!("// Auto-generated code, DO NOT EDIT DIRECTLY!"); @@ -42,3 +42,4 @@ pub(crate) use insert; pub use ast::AstGenerator; pub use ast_kind::AstKindGenerator; pub use impl_get_span::ImplGetSpanGenerator; +pub use visit::VisitGenerator; diff --git a/tasks/ast_codegen/src/generators/visit.rs b/tasks/ast_codegen/src/generators/visit.rs new file mode 100644 index 000000000000..0ae0e3b70f10 --- /dev/null +++ b/tasks/ast_codegen/src/generators/visit.rs @@ -0,0 +1,801 @@ +use std::{ + borrow::Cow, + collections::{HashMap, HashSet}, + iter::Cloned, +}; + +use convert_case::{Case, Casing}; +use itertools::Itertools; +use proc_macro2::{TokenStream, TokenTree}; +use quote::{format_ident, quote, ToTokens}; +use syn::{ + parenthesized, + parse::{Parse, ParseStream}, + parse2, parse_quote, + punctuated::Punctuated, + spanned::Spanned, + token::Paren, + Arm, Attribute, Expr, Field, GenericArgument, Ident, Meta, MetaNameValue, Path, PathArguments, + Token, Type, Variant, +}; + +use crate::{ + generators::{ast_kind::BLACK_LIST as KIND_BLACK_LIST, insert}, + schema::{Inherit, REnum, RStruct, RType}, + util::{StrExt, TokenStreamExt, TypeExt, TypeIdentResult}, + CodegenCtx, Generator, GeneratorOutput, Result, TypeRef, +}; + +use super::generated_header; + +pub struct VisitGenerator; + +impl Generator for VisitGenerator { + fn name(&self) -> &'static str { + "VisitGenerator" + } + + fn generate(&mut self, ctx: &CodegenCtx) -> GeneratorOutput { + let visit = (String::from("visit"), generate_visit(ctx)); + let visit_mut = (String::from("visit_mut"), generate_visit_mut(ctx)); + + GeneratorOutput::Many(HashMap::from_iter(vec![visit, visit_mut])) + } +} + +static CLIPPY_ALLOW: &str = "\ + unused_variables,\ + clippy::extra_unused_type_parameters,\ + clippy::explicit_iter_loop,\ + clippy::self_named_module_files,\ + clippy::semicolon_if_nothing_returned,\ + clippy::match_wildcard_for_single_variants"; + +fn generate_visit(ctx: &CodegenCtx) -> TokenStream { + let header = generated_header!(); + // we evaluate it outside of quote to take advantage of expression evaluation + // otherwise the `\n\` wouldn't work! + let file_docs = insert! {"\ + //! Visitor Pattern\n\ + //!\n\ + //! See:\n\ + //! * [visitor pattern](https://rust-unofficial.github.io/patterns/patterns/behavioural/visitor.html)\n\ + //! * [rustc visitor](https://github.com/rust-lang/rust/blob/master/compiler/rustc_ast/src/visit.rs)\n\ + "}; + + let (visits, walks) = VisitBuilder::new(ctx, false).build(); + let clippy_attr = insert!("#![allow({})]", CLIPPY_ALLOW); + + quote! { + #header + #file_docs + #clippy_attr + + endl!(); + + use oxc_allocator::Vec; + use oxc_syntax::scope::ScopeFlags; + + endl!(); + + use crate::{ast::*, ast_kind::AstKind}; + + endl!(); + + use walk::*; + + endl!(); + + /// Syntax tree traversal + pub trait Visit<'a>: Sized { + fn enter_node(&mut self, kind: AstKind<'a>) {} + fn leave_node(&mut self, kind: AstKind<'a>) {} + + endl!(); + + fn enter_scope(&mut self, flags: ScopeFlags) {} + fn leave_scope(&mut self) {} + + endl!(); + + #[inline] + fn alloc(&self, t: &T) -> &'a T { + insert!("// SAFETY:"); + insert!("// This should be safe as long as `src` is an reference from the allocator."); + insert!("// But honestly, I'm not really sure if this is safe."); + #[allow(unsafe_code)] + unsafe { + std::mem::transmute(t) + } + } + + #(#visits)* + } + + endl!(); + + pub mod walk { + use super::*; + + #(#walks)* + + } + } +} + +fn generate_visit_mut(ctx: &CodegenCtx) -> TokenStream { + let header = generated_header!(); + // we evaluate it outside of quote to take advantage of expression evaluation + // otherwise the `\n\` wouldn't work! + let file_docs = insert! {"\ + //! Visitor Pattern\n\ + //!\n\ + //! See:\n\ + //! * [visitor pattern](https://rust-unofficial.github.io/patterns/patterns/behavioural/visitor.html)\n\ + //! * [rustc visitor](https://github.com/rust-lang/rust/blob/master/compiler/rustc_ast/src/visit.rs)\n\ + "}; + + let (visits, walks) = VisitBuilder::new(ctx, true).build(); + let clippy_attr = insert!("#![allow({})]", CLIPPY_ALLOW); + + quote! { + #header + #file_docs + #clippy_attr + + endl!(); + + use oxc_allocator::Vec; + use oxc_syntax::scope::ScopeFlags; + + endl!(); + + use crate::{ast::*, ast_kind::AstType}; + + endl!(); + + use walk_mut::*; + + endl!(); + + /// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in place. + pub trait VisitMut<'a>: Sized { + fn enter_node(&mut self, ty: AstType) {} + fn leave_node(&mut self, ty: AstType) {} + + endl!(); + + fn enter_scope(&mut self, flags: ScopeFlags) {} + fn leave_scope(&mut self) {} + + endl!(); + + #(#visits)* + } + + endl!(); + + pub mod walk_mut { + use super::*; + + #(#walks)* + + } + } +} + +struct VisitBuilder<'a> { + ctx: &'a CodegenCtx, + + is_mut: bool, + + visits: Vec, + walks: Vec, + cache: HashMap>; 2]>, +} + +impl<'a> VisitBuilder<'a> { + fn new(ctx: &'a CodegenCtx, is_mut: bool) -> Self { + Self { ctx, is_mut, visits: Vec::new(), walks: Vec::new(), cache: HashMap::new() } + } + + fn build(mut self) -> (/* visits */ Vec, /* walks */ Vec) { + let program = { + let types: Vec<&TypeRef> = + self.ctx.ty_table.iter().filter(|it| it.borrow().visitable()).collect_vec(); + TypeRef::clone( + types + .iter() + .find(|it| it.borrow().ident().is_some_and(|ident| ident == "Program")) + .expect("Couldn't find the `Program` type!"), + ) + }; + + self.get_visitor(&program, false, None); + (self.visits, self.walks) + } + + fn with_ref_pat(&self, tk: T) -> TokenStream + where + T: ToTokens, + { + if self.is_mut { + quote!(&mut #tk) + } else { + quote!(&#tk) + } + } + + fn kind_type(&self, ident: &Ident) -> TokenStream { + if self.is_mut { + quote!(AstType::#ident) + } else { + quote!(AstKind::#ident(visitor.alloc(it))) + } + } + + fn get_iter(&self) -> TokenStream { + if self.is_mut { + quote!(iter_mut) + } else { + quote!(iter) + } + } + + fn get_visitor( + &mut self, + ty: &TypeRef, + collection: bool, + visit_as: Option<&Ident>, + ) -> Cow<'a, Ident> { + let cache_ix = usize::from(collection); + let (ident, as_type) = { + let ty = ty.borrow(); + debug_assert!(ty.visitable(), "{ty:?}"); + + let ident = ty.ident().unwrap(); + let as_type = ty.as_type().unwrap(); + + let ident = visit_as.unwrap_or(ident); + + (ident.clone(), if collection { parse_quote!(Vec<'a, #as_type>) } else { as_type }) + }; + + // is it already generated? + if let Some(cached) = self.cache.get(&ident) { + if let Some(cached) = &cached[cache_ix] { + return Cow::clone(cached); + } + } + + let ident_snake = { + let it = ident.to_string().to_case(Case::Snake); + let it = if collection { + // edge case for `Vec` to avoid conflicts with `FormalParameters` + // which both would generate the same name: `visit_formal_parameters`. + // and edge case for `Vec` to avoid conflicts with + // `TSImportAttributes` which both would generate the same name: `visit_formal_parameters`. + if matches!(it.as_str(), "formal_parameter" | "ts_import_attribute") { + let mut it = it; + it.push_str("_list"); + it + } else { + it.to_plural() + } + } else { + it + }; + format_ident!("{it}") + }; + + let as_param_type = self.with_ref_pat(&as_type); + let (extra_params, extra_args) = if ident == "Function" { + (quote!(, flags: Option,), quote!(, flags)) + } else { + (TokenStream::default(), TokenStream::default()) + }; + + let visit_name = { + let visit_name = format_ident!("visit_{}", ident_snake); + if !self.cache.contains_key(&ident) { + debug_assert!(self.cache.insert(ident.clone(), [None, None]).is_none()); + } + let cached = self.cache.get_mut(&ident).unwrap(); + assert!(cached[cache_ix].replace(Cow::Owned(visit_name)).is_none()); + Cow::clone(cached[cache_ix].as_ref().unwrap()) + }; + + let walk_name = format_ident!("walk_{}", ident_snake); + + self.visits.push(quote! { + endl!(); + #[inline] + fn #visit_name (&mut self, it: #as_param_type #extra_params) { + #walk_name(self, it #extra_args); + } + }); + + // We push an empty walk first, because we evaluate - and generate - each walk as we go, + // This would let us to maintain the order of first visit. + let this_walker = self.walks.len(); + self.walks.push(TokenStream::default()); + + let (walk_body, may_inline) = if collection { + let singular_visit = self.get_visitor(ty, false, None); + let iter = self.get_iter(); + ( + quote! { + for el in it.#iter() { + visitor.#singular_visit(el); + } + }, + true, + ) + } else { + match &*ty.borrow() { + RType::Enum(enum_) => self.generate_enum_walk(enum_, visit_as), + RType::Struct(struct_) => self.generate_struct_walk(struct_, visit_as), + _ => panic!(), + } + }; + + let visit_trait = if self.is_mut { quote!(VisitMut) } else { quote!(Visit) }; + let may_inline = if may_inline { Some(quote!(#[inline])) } else { None }; + + // replace the placeholder walker with the actual one! + self.walks[this_walker] = quote! { + endl!(); + #may_inline + pub fn #walk_name <'a, V: #visit_trait<'a>>(visitor: &mut V, it: #as_param_type #extra_params) { + #walk_body + } + }; + + visit_name + } + + fn generate_enum_walk( + &mut self, + enum_: &REnum, + visit_as: Option<&Ident>, + ) -> (TokenStream, /* inline */ bool) { + let ident = enum_.ident(); + let mut non_exhaustive = false; + let variants_matches = enum_ + .item + .variants + .iter() + .filter(|it| !it.attrs.iter().any(|a| a.path().is_ident("inherit"))) + .filter(|it| { + if it.attrs.iter().any(|a| { + a.path().is_ident("visit") + && a.meta + .require_list() + .unwrap() + .parse_args::() + .unwrap() + .is_ident("ignore") + }) { + // We are ignoring some variants so the match is no longer exhaustive. + non_exhaustive = true; + false + } else { + true + } + }) + .filter_map(|it| { + let typ = it + .fields + .iter() + .exactly_one() + .map(|f| &f.ty) + .map_err(|_| "We only support visited enum nodes with exactly one field!") + .unwrap(); + let variant_name = &it.ident; + let typ = self.ctx.find(&typ.get_ident().inner_ident().to_string())?; + let borrowed = typ.borrow(); + let visitable = borrowed.visitable(); + if visitable { + let visit = self.get_visitor(&typ, false, None); + let (args_def, args) = it + .attrs + .iter() + .find(|it| it.path().is_ident("visit_args")) + .map(|it| it.parse_args_with(VisitArgs::parse)) + .map(|it| { + it.into_iter() + .flatten() + .fold((Vec::new(), Vec::new()), Self::visit_args_fold) + }) + .unwrap_or_default(); + let body = quote!(visitor.#visit(it #(#args)*)); + let body = if args_def.is_empty() { + body + } else { + // if we have args wrap the result in a block to prevent ident clashes. + quote! {{ + #(#args_def)* + #body + }} + }; + Some(quote!(#ident::#variant_name(it) => #body)) + } else { + None + } + }) + .collect_vec(); + + let inherit_matches = enum_.meta.inherits.iter().filter_map(|it| { + let Inherit::Linked { super_, .. } = it else { panic!("Unresolved inheritance!") }; + let type_name = super_.get_ident().as_ident().unwrap().to_string(); + let typ = self.ctx.find(&type_name)?; + if typ.borrow().visitable() { + let snake_name = type_name.to_case(Case::Snake); + let match_macro = format_ident!("match_{snake_name}"); + let match_macro = quote!(#match_macro!(#ident)); + // HACK: edge case till we get attributes to work with inheritance. + let visit_as = if ident == "ArrayExpressionElement" + && super_.get_ident().inner_ident() == "Expression" + { + Some(format_ident!("ExpressionArrayElement")) + } else { + None + }; + let to_child = if self.is_mut { + format_ident!("to_{snake_name}_mut") + } else { + format_ident!("to_{snake_name}") + }; + let visit = self.get_visitor(&typ, false, visit_as.as_ref()); + Some(quote!(#match_macro => visitor.#visit(it.#to_child()))) + } else { + None + } + }); + + let matches = variants_matches.into_iter().chain(inherit_matches).collect_vec(); + + let with_node_events = |tk| { + let ident = visit_as.unwrap_or(ident); + if KIND_BLACK_LIST.contains(&ident.to_string().as_str()) { + tk + } else { + let kind = self.kind_type(ident); + quote! { + let kind = #kind; + visitor.enter_node(kind); + #tk + visitor.leave_node(kind); + } + } + }; + let non_exhaustive = if non_exhaustive { Some(quote!(,_ => {})) } else { None }; + ( + with_node_events(quote!(match it { #(#matches),* #non_exhaustive })), + // inline if there are 5 or less match cases + matches.len() <= 5, + ) + } + + fn generate_struct_walk( + &mut self, + struct_: &RStruct, + visit_as: Option<&Ident>, + ) -> (TokenStream, /* inline */ bool) { + let ident = visit_as.unwrap_or_else(|| struct_.ident()); + let scope_attr = struct_.item.attrs.iter().find(|it| it.path().is_ident("scope")); + let (scope_enter, scope_leave) = scope_attr + .map(parse_as_scope) + .transpose() + .unwrap() + .map_or_else(Default::default, |scope_args| { + let cond = scope_args.r#if.map(|cond| { + let cond = cond.to_token_stream().replace_ident("self", &format_ident!("it")); + quote!(let scope_events_cond = #cond;) + }); + let maybe_conditional = |tk: TokenStream| { + if cond.is_some() { + quote! { + if scope_events_cond { + #tk + } + } + } else { + tk + } + }; + let flags = scope_args + .flags + .map_or_else(|| quote!(ScopeFlags::empty()), |it| it.to_token_stream()); + let args = if let Some(strict_if) = scope_args.strict_if { + let strict_if = + strict_if.to_token_stream().replace_ident("self", &format_ident!("it")); + quote! {{ + let mut flags = #flags; + if #strict_if { + flags |= ScopeFlags::StrictMode; + } + flags + }} + } else { + flags + }; + let mut enter = cond.as_ref().into_token_stream(); + enter.extend(maybe_conditional(quote!(visitor.enter_scope(#args);))); + let leave = maybe_conditional(quote!(visitor.leave_scope();)); + (Some(enter), Some(leave)) + }); + let mut entered_scope = false; + let fields_visits: Vec = struct_ + .item + .fields + .iter() + .filter_map(|it| { + let (typ, typ_wrapper) = self.analyze_type(&it.ty)?; + let visit_as: Option = + it.attrs.iter().find(|it| it.path().is_ident("visit_as")).map(|it| { + match &it.meta { + Meta::List(meta) => { + parse2(meta.tokens.clone()).expect("wrong `visit_as` input!") + } + _ => panic!("wrong use of `visit_as`!"), + } + }); + // TODO: make sure it is `#[scope(enter_before)]` + let have_enter_scope = it.attrs.iter().any(|it| it.path().is_ident("scope")); + let args = it.attrs.iter().find(|it| it.meta.path().is_ident("visit_args")); + let (args_def, args) = args + .map(|it| it.parse_args_with(VisitArgs::parse)) + .map(|it| { + it.into_iter() + .flatten() + .fold((Vec::new(), Vec::new()), Self::visit_args_fold) + }) + .unwrap_or_default(); + let visit = self.get_visitor( + &typ, + matches!( + typ_wrapper, + TypeWrapper::Vec | TypeWrapper::VecBox | TypeWrapper::OptVec + ), + visit_as.as_ref(), + ); + let name = it.ident.as_ref().expect("expected named fields!"); + let borrowed_field = self.with_ref_pat(quote!(it.#name)); + let mut result = match typ_wrapper { + TypeWrapper::Opt | TypeWrapper::OptBox | TypeWrapper::OptVec => quote! { + if let Some(#name) = #borrowed_field { + visitor.#visit(#name #(#args)*); + } + }, + TypeWrapper::VecOpt => { + let iter = self.get_iter(); + quote! { + for #name in it.#name.#iter().flatten() { + visitor.#visit(#name #(#args)*); + } + } + } + _ => quote! { + visitor.#visit(#borrowed_field #(#args)*); + }, + }; + if have_enter_scope { + assert!(!entered_scope); + result = quote! { + #scope_enter + #result + }; + entered_scope = true; + } + + if args_def.is_empty() { + Some(result) + } else { + // if we have args wrap the result in a block to prevent ident clashes. + Some(quote! {{ + #(#args_def)* + #result + }}) + } + }) + .collect(); + + let body = if KIND_BLACK_LIST.contains(&ident.to_string().as_str()) { + let note = insert!( + "// NOTE: {} doesn't exists!", + if self.is_mut { "AstType" } else { "AstKind" } + ); + quote! { + #note + #(#fields_visits)* + } + } else { + let kind = self.kind_type(ident); + quote! { + let kind = #kind; + visitor.enter_node(kind); + #(#fields_visits)* + visitor.leave_node(kind); + } + }; + + let result = match (scope_enter, scope_leave, entered_scope) { + (_, Some(leave), true) => quote! { + #body + #leave + }, + (Some(enter), Some(leave), false) => quote! { + #enter + #body + #leave + }, + _ => body, + }; + + // inline if there are 5 or less fields. + (result, fields_visits.len() <= 5) + } + + fn analyze_type(&self, ty: &Type) -> Option<(TypeRef, TypeWrapper)> { + fn analyze<'a>(res: &'a TypeIdentResult) -> Option<(&'a Ident, TypeWrapper)> { + let mut wrapper = TypeWrapper::None; + let ident = match res { + TypeIdentResult::Ident(inner) => inner, + TypeIdentResult::Box(inner) => { + wrapper = TypeWrapper::Box; + let (inner, inner_kind) = analyze(inner)?; + assert!(inner_kind == TypeWrapper::None,); + inner + } + TypeIdentResult::Vec(inner) => { + wrapper = TypeWrapper::Vec; + let (inner, inner_kind) = analyze(inner)?; + if inner_kind == TypeWrapper::Opt { + wrapper = TypeWrapper::VecOpt; + } else if inner_kind != TypeWrapper::None { + panic!(); + } + inner + } + TypeIdentResult::Option(inner) => { + wrapper = TypeWrapper::Opt; + let (inner, inner_kind) = analyze(inner)?; + if inner_kind == TypeWrapper::Vec { + wrapper = TypeWrapper::OptVec; + } else if inner_kind == TypeWrapper::Box { + wrapper = TypeWrapper::OptBox; + } else if inner_kind != TypeWrapper::None { + panic!(); + } + inner + } + TypeIdentResult::Reference(_) => return None, + }; + Some((ident, wrapper)) + } + let type_ident = ty.get_ident(); + let (type_ident, wrapper) = analyze(&type_ident)?; + + let type_ref = self.ctx.find(&type_ident.to_string())?; + if type_ref.borrow().visitable() { + Some((type_ref, wrapper)) + } else { + None + } + } + + fn visit_args_fold( + mut accumulator: (Vec, Vec), + arg: VisitArg, + ) -> (Vec, Vec) { + let VisitArg { ident: id, value: val } = arg; + let val = val.to_token_stream().replace_ident("self", &format_ident!("it")); + accumulator.0.push(quote!(let #id = #val;)); + accumulator.1.push(quote!(, #id)); + accumulator + } +} + +#[derive(PartialEq)] +enum TypeWrapper { + None, + Box, + Vec, + Opt, + VecBox, + VecOpt, + OptBox, + OptVec, +} + +#[derive(Debug)] +struct VisitArgs(Punctuated); + +impl IntoIterator for VisitArgs { + type Item = VisitArg; + type IntoIter = syn::punctuated::IntoIter; + fn into_iter(self) -> Self::IntoIter { + self.0.into_iter() + } +} + +#[derive(Debug)] +struct VisitArg { + ident: Ident, + value: Expr, +} + +#[derive(Debug, Default)] +struct ScopeArgs { + r#if: Option, + flags: Option, + strict_if: Option, +} + +impl Parse for VisitArgs { + fn parse(input: ParseStream) -> std::result::Result { + input.parse_terminated(VisitArg::parse, Token![,]).map(Self) + } +} + +impl Parse for VisitArg { + fn parse(input: ParseStream) -> std::result::Result { + let nv: MetaNameValue = input.parse()?; + Ok(Self { + ident: nv.path.get_ident().map_or_else( + || Err(syn::Error::new(nv.span(), "Invalid `visit_args` input!")), + |it| Ok(it.clone()), + )?, + value: nv.value, + }) + } +} + +impl Parse for ScopeArgs { + fn parse(input: ParseStream) -> std::result::Result { + fn parse(input: ParseStream) -> std::result::Result<(String, Expr), syn::Error> { + let ident = if let Ok(ident) = input.parse::() { + ident.to_string() + } else if input.parse::().is_ok() { + String::from("if") + } else { + return Err(syn::Error::new(input.span(), "Invalid `#[scope]` input.")); + }; + let content; + parenthesized!(content in input); + Ok((ident, content.parse()?)) + } + + let parsed = input.parse_terminated(parse, Token![,])?; + Ok(parsed.into_iter().fold(Self::default(), |mut acc, (ident, expr)| { + match ident.as_str() { + "if" => acc.r#if = Some(expr), + "flags" => acc.flags = Some(expr), + "strict_if" => acc.strict_if = Some(expr), + _ => {} + } + acc + })) + } +} + +fn parse_as_visit_args(attr: &Attribute) -> Vec<(Ident, TokenStream)> { + debug_assert!(attr.path().is_ident("visit_args")); + let mut result = Vec::new(); + let args: MetaNameValue = attr.parse_args().expect("Invalid `visit_args` input!"); + let ident = args.path.get_ident().unwrap().clone(); + let value = args.value.to_token_stream(); + result.push((ident, value)); + result +} + +fn parse_as_scope(attr: &Attribute) -> std::result::Result { + debug_assert!(attr.path().is_ident("scope")); + if matches!(attr.meta, Meta::Path(_)) { + // empty! + Ok(ScopeArgs::default()) + } else { + attr.parse_args_with(ScopeArgs::parse) + } +} diff --git a/tasks/ast_codegen/src/linker.rs b/tasks/ast_codegen/src/linker.rs index 41e46391f695..6d78f411a96a 100644 --- a/tasks/ast_codegen/src/linker.rs +++ b/tasks/ast_codegen/src/linker.rs @@ -1,5 +1,7 @@ use std::collections::VecDeque; +use syn::parse_quote; + use super::{CodegenCtx, Cow, Inherit, Itertools, RType, Result}; pub trait Linker<'a> { @@ -75,19 +77,27 @@ pub fn linker(ty: &mut RType, ctx: &CodegenCtx) -> Result { .map(|it| match it { Inherit::Unlinked(ref sup) => { let linkee = ctx.find(&Cow::Owned(sup.to_string())).unwrap(); - let variants = match &*linkee.borrow() { + let linkee = linkee.borrow(); + let inherit_value = format!(r#""{}""#, linkee.ident().unwrap()); + let variants = match &*linkee { RType::Enum(enum_) => { if enum_.meta.inherits.unresolved() { return Err(it); } - enum_.item.variants.clone() + enum_.item.variants.clone().into_iter().map(|mut v| { + v.attrs = vec![parse_quote!(#[inherit = #inherit_value])]; + v + }) } _ => { panic!("invalid inheritance, you can only inherit from enums and in enums.") } }; ty.item.variants.extend(variants.clone()); - Ok(Inherit::Linked { super_: sup.clone(), variants }) + Ok(Inherit::Linked { + super_: linkee.as_type().unwrap(), + variants: variants.collect(), + }) } Inherit::Linked { .. } => Ok(it), }) diff --git a/tasks/ast_codegen/src/main.rs b/tasks/ast_codegen/src/main.rs index 3d1ad02976ed..717ec7b1f3c8 100644 --- a/tasks/ast_codegen/src/main.rs +++ b/tasks/ast_codegen/src/main.rs @@ -5,6 +5,7 @@ mod fmt; mod generators; mod linker; mod schema; +mod util; use std::{ borrow::Cow, @@ -22,7 +23,7 @@ use proc_macro2::TokenStream; use syn::parse_file; use defs::TypeDef; -use generators::{AstGenerator, AstKindGenerator}; +use generators::{AstGenerator, AstKindGenerator, VisitGenerator}; use linker::{linker, Linker}; use schema::{Inherit, Module, REnum, RStruct, RType, Schema}; @@ -191,6 +192,7 @@ fn main() -> std::result::Result<(), Box> { .with(AstGenerator) .with(AstKindGenerator) .with(ImplGetSpanGenerator) + .with(VisitGenerator) .generate()?; let output_dir = output_dir()?; @@ -218,6 +220,19 @@ fn main() -> std::result::Result<(), Box> { file.write_all(span_content.as_bytes())?; } + { + // write `visit.rs` and `visit_mut.rs` files + let output = outputs[VisitGenerator.name()].as_many(); + let content = pprint(&output["visit"]); + let content_mut = pprint(&output["visit_mut"]); + + let mut visit = fs::File::create(format!("{output_dir}/visit.rs"))?; + let mut visit_mut = fs::File::create(format!("{output_dir}/visit_mut.rs"))?; + + visit.write_all(content.as_bytes())?; + visit_mut.write_all(content_mut.as_bytes())?; + } + cargo_fmt(".")?; // let schema = serde_json::to_string_pretty(&schema).map_err(|e| e.to_string())?; diff --git a/tasks/ast_codegen/src/schema.rs b/tasks/ast_codegen/src/schema.rs index c47800460021..a2c301907505 100644 --- a/tasks/ast_codegen/src/schema.rs +++ b/tasks/ast_codegen/src/schema.rs @@ -27,7 +27,7 @@ pub struct Definitions { #[derive(Debug, Clone)] pub enum Inherit { Unlinked(String), - Linked { super_: String, variants: Punctuated }, + Linked { super_: Type, variants: Punctuated }, } impl From for Inherit { diff --git a/tasks/ast_codegen/src/util.rs b/tasks/ast_codegen/src/util.rs new file mode 100644 index 000000000000..7f94fb590869 --- /dev/null +++ b/tasks/ast_codegen/src/util.rs @@ -0,0 +1,154 @@ +use itertools::Itertools; +use proc_macro2::{Group, TokenStream, TokenTree}; +use quote::{quote, ToTokens}; +use syn::{GenericArgument, Ident, PathArguments, Type, TypePath}; + +pub trait TokenStreamExt { + fn replace_ident(self, needle: &str, replace: &Ident) -> TokenStream; +} + +pub trait TypeExt { + fn get_ident(&self) -> TypeIdentResult; +} + +pub trait StrExt: AsRef { + /// Dead simple, just adds either `s` or `es` based on the last character. + /// doesn't handle things like `sh`, `x`, `z`, etc. It also creates wrong results when the word + /// ends with `y` but there is a preceding vowl similar to `toys`, + /// It WILL output the WRONG result `toies`! + /// As an edge case would output `children` for the input `child`. + fn to_plural(self) -> String; +} + +#[derive(Debug)] +pub enum TypeIdentResult<'a> { + Ident(&'a Ident), + Vec(Box>), + Box(Box>), + Option(Box>), + Reference(Box>), +} + +impl<'a> TypeIdentResult<'a> { + fn boxed(inner: Self) -> Self { + Self::Box(Box::new(inner)) + } + + fn vec(inner: Self) -> Self { + Self::Vec(Box::new(inner)) + } + + fn option(inner: Self) -> Self { + Self::Option(Box::new(inner)) + } + + fn reference(inner: Self) -> Self { + Self::Reference(Box::new(inner)) + } + + pub fn inner_ident(&self) -> &'a Ident { + match self { + Self::Ident(it) => it, + Self::Vec(it) | Self::Box(it) | Self::Option(it) | Self::Reference(it) => { + it.inner_ident() + } + } + } + + pub fn as_ident(&self) -> Option<&'a Ident> { + if let Self::Ident(it) = self { + Some(it) + } else { + None + } + } +} + +impl TypeExt for Type { + fn get_ident(&self) -> TypeIdentResult { + match self { + Type::Path(TypePath { path, .. }) => { + let seg1 = path.segments.first().unwrap(); + match &seg1.arguments { + PathArguments::None => TypeIdentResult::Ident(&seg1.ident), + PathArguments::AngleBracketed(it) => { + let args = &it.args.iter().collect_vec(); + assert!(args.len() < 3, "Max path arguments here is 2, eg `Box<'a, Adt>`"); + if let Some(second) = args.get(1) { + let GenericArgument::Type(second) = second else { panic!() }; + let inner = second.get_ident(); + if seg1.ident == "Box" { + TypeIdentResult::boxed(inner) + } else if seg1.ident == "Vec" { + TypeIdentResult::vec(inner) + } else { + panic!(); + } + } else { + match args.first() { + Some(GenericArgument::Type(it)) => { + let inner = it.get_ident(); + if seg1.ident == "Option" { + TypeIdentResult::option(inner) + } else { + inner + } + } + Some(GenericArgument::Lifetime(_)) => { + TypeIdentResult::Ident(&seg1.ident) + } + _ => panic!("unsupported type!"), + } + } + } + PathArguments::Parenthesized(_) => { + panic!("Parenthesized path arguments aren't supported!") + } + } + } + Type::Reference(typ) => TypeIdentResult::reference(typ.elem.get_ident()), + _ => panic!("Unsupported type."), + } + } +} + +impl> StrExt for T { + fn to_plural(self) -> String { + let txt = self.as_ref(); + if txt.is_empty() { + return String::default(); + } + + let mut txt = txt.to_string(); + if txt.ends_with("child") { + txt.push_str("ren"); + } else { + match txt.chars().last() { + Some('s') => { + txt.push_str("es"); + } + Some('y') => { + txt.pop(); + txt.push_str("ies"); + } + _ => txt.push('s'), + } + } + txt + } +} + +impl TokenStreamExt for TokenStream { + fn replace_ident(self, needle: &str, replace: &Ident) -> TokenStream { + self.into_iter() + .map(|it| match it { + TokenTree::Ident(ident) if ident == needle => replace.to_token_stream(), + TokenTree::Group(group) => { + Group::new(group.delimiter(), group.stream().replace_ident(needle, replace)) + .to_token_stream() + } + _ => it.to_token_stream(), + }) + .collect() + } +} diff --git a/tasks/coverage/parser_babel.snap b/tasks/coverage/parser_babel.snap index 32a146dee58e..bcc3d0ab8e95 100644 --- a/tasks/coverage/parser_babel.snap +++ b/tasks/coverage/parser_babel.snap @@ -1439,7 +1439,7 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" · ─ ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[core/uncategorised/396/input.js:1:12] 1 │ function t(...rest, b) { } · ─────── @@ -2289,7 +2289,7 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" · ─ ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[core/uncategorised/555/input.js:3:5] 2 │ first, 3 │ ...second, @@ -2321,7 +2321,7 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" · ──── ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[es2015/arrow-functions/comma-after-rest-param/input.js:1:2] 1 │ (...rest,) => {} · ─────── @@ -2383,7 +2383,7 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" ╰──── help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[es2015/arrow-functions/invalid-rest-in-params/input.js:3:5] 2 │ first, 3 │ ...second, @@ -3984,7 +3984,7 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" · ─ ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[es2015/uncategorised/277/input.js:1:15] 1 │ function f(a, ...b, c) { } · ──── @@ -4011,7 +4011,7 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" · ╰── `a` has already been declared here ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[es2015/uncategorised/283/input.js:1:2] 1 │ (...a, b) => {} · ──── @@ -5191,7 +5191,7 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" 3 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[es2017/async-functions/params-invalid-rest-trailing-comma/input.js:1:8] 1 │ async (...a,) => {}; · ──── @@ -5441,6 +5441,12 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" · ──── ╰──── + × Unexpected trailing comma after rest element + ╭─[es2018/object-rest-spread/8/input.js:1:17] + 1 │ let { x, y, ...z, } = obj; + · ─ + ╰──── + × A rest element must be last in a destructuring pattern ╭─[es2018/object-rest-spread/8/input.js:1:13] 1 │ let { x, y, ...z, } = obj; @@ -6971,6 +6977,12 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" · ─ ╰──── + × A rest element must be last in a destructuring pattern + ╭─[esprima/es2015-array-binding-pattern/invalid-elision-after-rest/input.js:1:5] + 1 │ ([a,...b,])=>0; + · ──── + ╰──── + × Identifier `a` has already been declared ╭─[esprima/es2015-array-pattern/dupe-param-1/input.js:2:13] 1 │ "use strict"; @@ -7012,13 +7024,13 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" · ╰── `,` expected ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[esprima/es2015-arrow-function/arrow-with-multiple-rest/input.js:1:2] 1 │ (...a, ...b) => 0 · ──── ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[esprima/es2015-arrow-function/arrow-with-multiple-rest/input.js:1:2] 1 │ (...a, ...b) => 0 · ──── @@ -9574,7 +9586,7 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" ╰──── help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[esprima/invalid-syntax/migrated_0258/input.js:1:15] 1 │ function f(a, ...b, c){} · ──── diff --git a/tasks/coverage/parser_test262.snap b/tasks/coverage/parser_test262.snap index 7e1f3f694f16..67c9743c10d3 100644 --- a/tasks/coverage/parser_test262.snap +++ b/tasks/coverage/parser_test262.snap @@ -2126,7 +2126,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 131 │ }; ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/arrow-function/rest-params-trailing-comma-early-error.js:54:5] 53 │ 54 │ 0, (...a,) => { @@ -5392,7 +5392,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 123 │ }); ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/async-arrow-function/rest-params-trailing-comma-early-error.js:46:9] 45 │ 46 │ (async (...a,) => { @@ -5651,7 +5651,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 109 │ }); ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/async-function/named-rest-params-trailing-comma-early-error.js:33:19] 32 │ 33 │ (async function f(...a,) { @@ -5701,7 +5701,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 109 │ }); ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/async-function/nameless-rest-params-trailing-comma-early-error.js:33:17] 32 │ 33 │ (async function(...a,) { @@ -6275,7 +6275,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 112 │ }; ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/async-generator/named-rest-params-trailing-comma-early-error.js:36:22] 35 │ 36 │ 0, async function* g(...a,) { @@ -6405,7 +6405,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 112 │ }; ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/async-generator/rest-params-trailing-comma-early-error.js:36:20] 35 │ 36 │ 0, async function*(...a,) { @@ -6656,7 +6656,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 136 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/class/async-gen-method/rest-params-trailing-comma-early-error.js:60:17] 59 │ 0, class { 60 │ async *method(...a,) { @@ -6876,7 +6876,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 136 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/class/async-gen-method-static/rest-params-trailing-comma-early-error.js:60:24] 59 │ 0, class { 60 │ static async *method(...a,) { @@ -7096,7 +7096,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 134 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/class/async-method/rest-params-trailing-comma-early-error.js:57:23] 56 │ var C = class { 57 │ static async method(...a,) { @@ -7210,7 +7210,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 134 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/class/async-method-static/rest-params-trailing-comma-early-error.js:57:23] 56 │ var C = class { 57 │ static async method(...a,) { @@ -12223,7 +12223,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 157 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/class/gen-method/rest-params-trailing-comma-early-error.js:81:11] 80 │ 0, class { 81 │ *method(...a,) { @@ -12388,7 +12388,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 157 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/class/gen-method-static/rest-params-trailing-comma-early-error.js:81:18] 80 │ 0, class { 81 │ static *method(...a,) { @@ -12551,7 +12551,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 153 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/class/method/rest-params-trailing-comma-early-error.js:76:10] 75 │ 0, class { 76 │ method(...a,) { @@ -12609,7 +12609,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 153 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/class/method-static/rest-params-trailing-comma-early-error.js:76:17] 75 │ 0, class { 76 │ static method(...a,) { @@ -14122,7 +14122,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 132 │ }; ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/function/rest-params-trailing-comma-early-error.js:55:13] 54 │ 55 │ 0, function(...a,) { @@ -14390,7 +14390,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 133 │ }; ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/generators/rest-params-trailing-comma-early-error.js:57:14] 56 │ 57 │ 0, function*(...a,) { @@ -15439,7 +15439,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 117 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/object/method-definition/async-gen-meth-rest-params-trailing-comma-early-error.js:41:17] 40 │ 0, { 41 │ async *method(...a,) { @@ -15603,7 +15603,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 110 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/object/method-definition/async-meth-rest-params-trailing-comma-early-error.js:34:17] 33 │ ({ 34 │ async *method(...a,) { @@ -15811,7 +15811,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 139 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/object/method-definition/gen-meth-rest-params-trailing-comma-early-error.js:63:11] 62 │ 0, { 63 │ *method(...a,) { @@ -16032,7 +16032,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 135 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/expressions/object/method-definition/meth-rest-params-trailing-comma-early-error.js:58:10] 57 │ 0, { 58 │ method(...a,) { @@ -20955,7 +20955,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" ╰──── help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/rest-parameters/position-invalid.js:13:15] 12 │ $DONOTEVALUATE(); 13 │ function f(a, ...b, c) {} @@ -21189,7 +21189,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 109 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/async-function/rest-params-trailing-comma-early-error.js:33:18] 32 │ 33 │ async function f(...a,) { @@ -21406,7 +21406,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 112 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/async-generator/rest-params-trailing-comma-early-error.js:36:19] 35 │ 36 │ async function* f(...a,) { @@ -21859,7 +21859,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 135 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/class/async-gen-method/rest-params-trailing-comma-early-error.js:59:17] 58 │ class C { 59 │ async *method(...a,) { @@ -22079,7 +22079,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 136 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/class/async-gen-method-static/rest-params-trailing-comma-early-error.js:60:24] 59 │ class C { 60 │ static async *method(...a,) { @@ -22307,7 +22307,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 134 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/class/async-method/rest-params-trailing-comma-early-error.js:57:16] 56 │ class C { 57 │ async method(...a,) { @@ -22421,7 +22421,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 133 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/class/async-method-static/rest-params-trailing-comma-early-error.js:56:23] 55 │ class C { 56 │ static async method(...a,) { @@ -27645,7 +27645,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 155 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/class/gen-method/rest-params-trailing-comma-early-error.js:79:11] 78 │ class C { 79 │ *method(...a,) { @@ -27810,7 +27810,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 155 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/class/gen-method-static/rest-params-trailing-comma-early-error.js:79:18] 78 │ class C { 79 │ static *method(...a,) { @@ -27973,7 +27973,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 152 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/class/method/rest-params-trailing-comma-early-error.js:75:10] 74 │ class C { 75 │ method(...a,) { @@ -28031,7 +28031,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 152 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/class/method-static/rest-params-trailing-comma-early-error.js:75:17] 74 │ class C { 75 │ static method(...a,) { @@ -31637,7 +31637,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 133 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/function/rest-params-trailing-comma-early-error.js:56:12] 55 │ 56 │ function f(...a,) { @@ -31807,7 +31807,7 @@ Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" 133 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[language/statements/generators/rest-params-trailing-comma-early-error.js:57:13] 56 │ 57 │ function* f(...a,) { diff --git a/tasks/coverage/parser_typescript.snap b/tasks/coverage/parser_typescript.snap index 6d6c34c1f077..a6e2a90b9fcc 100644 --- a/tasks/coverage/parser_typescript.snap +++ b/tasks/coverage/parser_typescript.snap @@ -1,9 +1,9 @@ commit: d8086f14 parser_typescript Summary: -AST Parsed : 5280/5283 (99.94%) -Positive Passed: 5273/5283 (99.81%) -Negative Passed: 1077/4875 (22.09%) +AST Parsed : 5279/5283 (99.92%) +Positive Passed: 5272/5283 (99.79%) +Negative Passed: 1082/4875 (22.19%) Expect Syntax Error: "compiler/ClassDeclaration10.ts" Expect Syntax Error: "compiler/ClassDeclaration11.ts" Expect Syntax Error: "compiler/ClassDeclaration13.ts" @@ -1510,7 +1510,6 @@ Expect Syntax Error: "compiler/reservedNameOnModuleImportWithInterface.ts" Expect Syntax Error: "compiler/resolvingClassDeclarationWhenInBaseTypeResolution.ts" Expect Syntax Error: "compiler/restArgAssignmentCompat.ts" Expect Syntax Error: "compiler/restInvalidArgumentType.ts" -Expect Syntax Error: "compiler/restParamModifier2.ts" Expect Syntax Error: "compiler/restParamsWithNonRestParams.ts" Expect Syntax Error: "compiler/restUnion3.ts" Expect Syntax Error: "compiler/returnInConstructor1.ts" @@ -1899,7 +1898,6 @@ Expect Syntax Error: "compiler/useBeforeDeclaration_propertyAssignment.ts" Expect Syntax Error: "compiler/useBeforeDeclaration_superClass.ts" Expect Syntax Error: "compiler/useUnknownInCatchVariables01.ts" Expect Syntax Error: "compiler/varAndFunctionShareName.ts" -Expect Syntax Error: "compiler/varArgConstructorMemberParameter.ts" Expect Syntax Error: "compiler/varBlock.ts" Expect Syntax Error: "compiler/varNameConflictsWithImportInDifferentPartOfModule.ts" Expect Syntax Error: "compiler/vararg.ts" @@ -2188,7 +2186,6 @@ Expect Syntax Error: "conformance/decorators/class/method/decoratorOnClassMethod Expect Syntax Error: "conformance/decorators/class/method/decoratorOnClassMethod6.ts" Expect Syntax Error: "conformance/decorators/class/method/decoratorOnClassMethod8.ts" Expect Syntax Error: "conformance/decorators/class/method/decoratorOnClassMethodOverload1.ts" -Expect Syntax Error: "conformance/decorators/class/method/parameter/decoratorOnClassMethodThisParameter.ts" Expect Syntax Error: "conformance/decorators/class/property/decoratorOnClassProperty11.ts" Expect Syntax Error: "conformance/decorators/class/property/decoratorOnClassProperty6.ts" Expect Syntax Error: "conformance/decorators/class/property/decoratorOnClassProperty7.ts" @@ -2196,7 +2193,6 @@ Expect Syntax Error: "conformance/decorators/decoratorCallGeneric.ts" Expect Syntax Error: "conformance/decorators/invalid/decoratorOnEnum.ts" Expect Syntax Error: "conformance/decorators/invalid/decoratorOnFunctionDeclaration.ts" Expect Syntax Error: "conformance/decorators/invalid/decoratorOnFunctionExpression.ts" -Expect Syntax Error: "conformance/decorators/invalid/decoratorOnFunctionParameter.ts" Expect Syntax Error: "conformance/decorators/invalid/decoratorOnImportEquals1.ts" Expect Syntax Error: "conformance/decorators/invalid/decoratorOnInterface.ts" Expect Syntax Error: "conformance/decorators/invalid/decoratorOnInternalModule.ts" @@ -3175,7 +3171,6 @@ Expect Syntax Error: "conformance/parser/ecmascript5/Protected/Protected7.ts" Expect Syntax Error: "conformance/parser/ecmascript5/RealWorld/parserindenter.ts" Expect Syntax Error: "conformance/parser/ecmascript5/RegressionTests/parser509534.ts" Expect Syntax Error: "conformance/parser/ecmascript5/RegressionTests/parser509618.ts" -Expect Syntax Error: "conformance/parser/ecmascript5/RegressionTests/parser509668.ts" Expect Syntax Error: "conformance/parser/ecmascript5/RegressionTests/parser509693.ts" Expect Syntax Error: "conformance/parser/ecmascript5/RegressionTests/parser509698.ts" Expect Syntax Error: "conformance/parser/ecmascript5/RegressionTests/parser536727.ts" @@ -3818,6 +3813,15 @@ Expect to Parse: "compiler/elidedEmbeddedStatementsReplacedWithSemicolon.ts" · ──── 24 │ const enum H {} ╰──── +Expect to Parse: "compiler/sourceMapValidationDecorators.ts" + + × Unexpected token + ╭─[compiler/sourceMapValidationDecorators.ts:18:7] + 17 │ @ParameterDecorator2(30) + 18 │ ...b: string[]) { + · ─── + 19 │ } + ╰──── Expect to Parse: "compiler/withStatementInternalComments.ts" × 'with' statements are not allowed @@ -8995,7 +8999,15 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 3 │ } ╰──── - × A rest element must be last in a destructuring pattern + × Unexpected token + ╭─[compiler/restParamModifier2.ts:2:24] + 1 │ class C { + 2 │ constructor(public ...rest: string[]) {} + · ─── + 3 │ } + ╰──── + + × A rest parameter must be last in a parameter list ╭─[compiler/restParameterNotLast.ts:1:12] 1 │ function f(...x, y) { } · ──── @@ -10530,6 +10542,14 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" ╰──── help: Try insert a semicolon here + × Unexpected token + ╭─[compiler/varArgConstructorMemberParameter.ts:10:25] + 9 │ class Foo3 { + 10 │ constructor (public ...args: string[]) { } + · ─── + 11 │ } + ╰──── + × Unexpected token ╭─[compiler/varArgWithNoParamName.ts:1:16] 1 │ function t1(...) {} @@ -12553,6 +12573,14 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 6 │ } ╰──── + × Unexpected token + ╭─[conformance/decorators/class/method/parameter/decoratorOnClassMethodThisParameter.ts:4:17] + 3 │ class C { + 4 │ method(@dec this: C) {} + · ──── + 5 │ } + ╰──── + × Expected a semicolon or an implicit semicolon after a statement, but found none ╭─[conformance/decorators/class/property/decoratorOnClassProperty3.ts:4:11] 3 │ class C { @@ -12586,6 +12614,14 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 5 │ } ╰──── + × Unexpected token + ╭─[conformance/decorators/invalid/decoratorOnFunctionParameter.ts:5:22] + 4 │ + 5 │ function direct(@dec this: C) { return this.n; } + · ──── + 6 │ function called(@dec() this: C) { return this.n; } + ╰──── + × Unexpected token ╭─[conformance/dynamicImport/importCallExpressionGrammarError.ts:5:8] 4 │ var a = ["./0"]; @@ -13004,12 +13040,12 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 15 │ function a4(...b = [1,2,3]) { } // Error, can't have initializer ╰──── - × A rest parameter cannot have an initializer - ╭─[conformance/es6/destructuring/destructuringParameterDeclaration4.ts:15:16] - 14 │ function a3(...b?) { } // Error, can't be optional - 15 │ function a4(...b = [1,2,3]) { } // Error, can't have initializer - · ─────────── - 16 │ function a5([a, b, [[c]]]) { } + × Unexpected token + ╭─[conformance/es6/destructuring/destructuringParameterDeclaration4.ts:29:24] + 28 │ class C { + 29 │ constructor(public ...temp) { } // Error, rest parameter can't have properties + · ─── + 30 │ } ╰──── × Expected `:` but found `}` @@ -15528,6 +15564,21 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 2 │ const {...b,} = {}; ╰──── + × A rest element must be last in a destructuring pattern + ╭─[conformance/es7/trailingCommasInBindingPatterns.ts:1:8] + 1 │ const [...a,] = []; + · ──── + 2 │ const {...b,} = {}; + ╰──── + + × Unexpected trailing comma after rest element + ╭─[conformance/es7/trailingCommasInBindingPatterns.ts:2:12] + 1 │ const [...a,] = []; + 2 │ const {...b,} = {}; + · ─ + 3 │ let c, d; + ╰──── + × A rest element must be last in a destructuring pattern ╭─[conformance/es7/trailingCommasInBindingPatterns.ts:2:8] 1 │ const [...a,] = []; @@ -15544,7 +15595,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 5 │ ({...d,} = {}); ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/es7/trailingCommasInFunctionParametersAndArguments.ts:5:13] 4 │ 5 │ function f2(...args,) {} @@ -16214,7 +16265,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 12 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/functions/functionOverloadErrorsSyntax.ts:9:25] 8 │ //Function overload signature with rest param followed by non-optional parameter 9 │ function fn5(x: string, ...y: any[], z: string); @@ -17888,7 +17939,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 4 │ }; ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/parser/ecmascript5/ParameterLists/parserParameterList1.ts:2:6] 1 │ class C { 2 │ F(...A, B) { } @@ -17995,6 +18046,14 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 5 │ ╰──── + × Unexpected token + ╭─[conformance/parser/ecmascript5/RegressionTests/parser509668.ts:3:23] + 2 │ // Doesn't work, but should + 3 │ constructor (public ...args: string[]) { } + · ─── + 4 │ } + ╰──── + × Empty parenthesized expression ╭─[conformance/parser/ecmascript5/RegressionTests/parser509669.ts:2:9] 1 │ function foo():any { @@ -20586,7 +20645,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 36 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParameterWithoutAnnotationIsAnyArray.ts:5:11] 4 │ var f = function foo(...x) { } 5 │ var f2 = (...x, ...y) => { } @@ -20594,7 +20653,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 6 │ ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParameterWithoutAnnotationIsAnyArray.ts:5:11] 4 │ var f = function foo(...x) { } 5 │ var f2 = (...x, ...y) => { } @@ -20602,7 +20661,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 6 │ ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParameterWithoutAnnotationIsAnyArray.ts:13:9] 12 │ (...x); 13 │ foo(...x, ...y); @@ -20610,7 +20669,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 14 │ } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParameterWithoutAnnotationIsAnyArray.ts:13:9] 12 │ (...x); 13 │ foo(...x, ...y); @@ -20618,7 +20677,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 14 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParameterWithoutAnnotationIsAnyArray.ts:23:21] 22 │ foo(...x) { }, 23 │ a: function foo(...x, ...y) { }, @@ -20626,7 +20685,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 24 │ b: (...x) => { } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParameterWithoutAnnotationIsAnyArray.ts:23:21] 22 │ foo(...x) { }, 23 │ a: function foo(...x, ...y) { }, @@ -20634,7 +20693,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 24 │ b: (...x) => { } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes.ts:5:11] 4 │ var f = function foo(...x: number) { } 5 │ var f2 = (...x: Date, ...y: boolean) => { } @@ -20642,7 +20701,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 6 │ ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes.ts:5:11] 4 │ var f = function foo(...x: number) { } 5 │ var f2 = (...x: Date, ...y: boolean) => { } @@ -20650,7 +20709,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 6 │ ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes.ts:13:9] 12 │ (...x: string); 13 │ foo(...x: number, ...y: number); @@ -20658,7 +20717,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 14 │ } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes.ts:13:9] 12 │ (...x: string); 13 │ foo(...x: number, ...y: number); @@ -20666,7 +20725,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 14 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes.ts:23:21] 22 │ foo(...x: string) { }, 23 │ a: function foo(...x: number, ...y: Date) { }, @@ -20674,7 +20733,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 24 │ b: (...x: string) => { } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes.ts:23:21] 22 │ foo(...x: string) { }, 23 │ a: function foo(...x: number, ...y: Date) { }, @@ -20682,7 +20741,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 24 │ b: (...x: string) => { } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:9:11] 8 │ var f = function foo(...x: MyThing) { } 9 │ var f2 = (...x: MyThing, ...y: MyThing) => { } @@ -20690,7 +20749,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 10 │ ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:9:11] 8 │ var f = function foo(...x: MyThing) { } 9 │ var f2 = (...x: MyThing, ...y: MyThing) => { } @@ -20698,7 +20757,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 10 │ ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:17:9] 16 │ (...x: MyThing); 17 │ foo(...x: MyThing, ...y: MyThing); @@ -20706,7 +20765,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 18 │ } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:17:9] 16 │ (...x: MyThing); 17 │ foo(...x: MyThing, ...y: MyThing); @@ -20714,7 +20773,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 18 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:27:21] 26 │ foo(...x: MyThing) { }, 27 │ a: function foo(...x: MyThing, ...y: MyThing) { }, @@ -20722,7 +20781,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 28 │ b: (...x: MyThing) => { } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:27:21] 26 │ foo(...x: MyThing) { }, 27 │ a: function foo(...x: MyThing, ...y: MyThing) { }, @@ -20730,7 +20789,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 28 │ b: (...x: MyThing) => { } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:36:11] 35 │ var f3 = function foo(...x: MyThing2) { } 36 │ var f4 = (...x: MyThing2, ...y: MyThing2) => { } @@ -20738,7 +20797,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 37 │ ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:36:11] 35 │ var f3 = function foo(...x: MyThing2) { } 36 │ var f4 = (...x: MyThing2, ...y: MyThing2) => { } @@ -20746,7 +20805,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 37 │ ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:44:9] 43 │ (...x: MyThing2); 44 │ foo(...x: MyThing2, ...y: MyThing2); @@ -20754,7 +20813,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 45 │ } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:44:9] 43 │ (...x: MyThing2); 44 │ foo(...x: MyThing2, ...y: MyThing2); @@ -20762,7 +20821,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 45 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:54:21] 53 │ foo(...x: MyThing2) { }, 54 │ a: function foo(...x: MyThing2, ...y: MyThing2) { }, @@ -20770,7 +20829,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 55 │ b: (...x: MyThing2) => { } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts:54:21] 53 │ foo(...x: MyThing2) { }, 54 │ a: function foo(...x: MyThing2, ...y: MyThing2) { }, @@ -20778,7 +20837,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 55 │ b: (...x: MyThing2) => { } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:5:11] 4 │ var f = function foo(...x: number[]) { } 5 │ var f2 = (...x: number[], ...y: number[]) => { } @@ -20786,7 +20845,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 6 │ ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:5:11] 4 │ var f = function foo(...x: number[]) { } 5 │ var f2 = (...x: number[], ...y: number[]) => { } @@ -20794,7 +20853,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 6 │ ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:13:9] 12 │ (...x: number[]); 13 │ foo(...x: number[], ...y: number[]); @@ -20802,7 +20861,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 14 │ } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:13:9] 12 │ (...x: number[]); 13 │ foo(...x: number[], ...y: number[]); @@ -20810,7 +20869,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 14 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:23:21] 22 │ foo(...x: number[]) { }, 23 │ a: function foo(...x: number[], ...y: number[]) { }, @@ -20818,7 +20877,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 24 │ b: (...x: number[]) => { } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:23:21] 22 │ foo(...x: number[]) { }, 23 │ a: function foo(...x: number[], ...y: number[]) { }, @@ -20826,7 +20885,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 24 │ b: (...x: number[]) => { } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:32:11] 31 │ var f3 = function foo(...x: Array) { } 32 │ var f4 = (...x: Array, ...y: Array) => { } @@ -20834,7 +20893,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 33 │ ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:32:11] 31 │ var f3 = function foo(...x: Array) { } 32 │ var f4 = (...x: Array, ...y: Array) => { } @@ -20842,7 +20901,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 33 │ ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:40:9] 39 │ (...x: Array); 40 │ foo(...x: Array, ...y: Array); @@ -20850,7 +20909,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 41 │ } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:40:9] 39 │ (...x: Array); 40 │ foo(...x: Array, ...y: Array); @@ -20858,7 +20917,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 41 │ } ╰──── - × A rest element must be last in a destructuring pattern + × A rest parameter must be last in a parameter list ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:50:21] 49 │ foo(...x: Array) { }, 50 │ a: function foo(...x: Array, ...y: Array) { }, @@ -20866,7 +20925,7 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 51 │ b: (...x: Array) => { } ╰──── - × A rest parameter must be last in a parameter list + × A rest element must be last in a destructuring pattern ╭─[conformance/types/objectTypeLiteral/callSignatures/restParametersWithArrayTypeAnnotations.ts:50:21] 49 │ foo(...x: Array) { }, 50 │ a: function foo(...x: Array, ...y: Array) { }, @@ -21020,13 +21079,12 @@ Expect to Parse: "conformance/salsa/plainJSRedeclare3.ts" 165 │ function notFirst(a: number, this: C): number { return this.n; } ╰──── - × Expected `,` but found `this` - ╭─[conformance/types/thisType/thisTypeInFunctionsNegative.ts:168:26] - 167 │ ///// parse errors ///// - 168 │ function modifiers(async this: C): number { return this.n; } - · ──┬─ - · ╰── `,` expected - 169 │ function restParam(...this: C): number { return this.n; } + × Unexpected token + ╭─[conformance/types/thisType/thisTypeInFunctionsNegative.ts:165:30] + 164 │ var thisConstructorType: new (this: number) => number; + 165 │ function notFirst(a: number, this: C): number { return this.n; } + · ──── + 166 │ ╰──── × Expected a semicolon or an implicit semicolon after a statement, but found none diff --git a/tasks/coverage/prettier_typescript.snap b/tasks/coverage/prettier_typescript.snap index 1bdc895b0a81..80d1ef63e690 100644 --- a/tasks/coverage/prettier_typescript.snap +++ b/tasks/coverage/prettier_typescript.snap @@ -2,7 +2,7 @@ commit: d8086f14 prettier_typescript Summary: AST Parsed : 5283/5283 (100.00%) -Positive Passed: 2447/5283 (46.32%) +Positive Passed: 2448/5283 (46.34%) Expect to Parse: "compiler/DeclarationErrorsNoEmitOnError.ts" Expect to Parse: "compiler/abstractInterfaceIdentifierName.ts" Expect to Parse: "compiler/abstractPropertyBasics.ts" @@ -1408,7 +1408,6 @@ Expect to Parse: "compiler/sourceMap-FileWithComments.ts" Expect to Parse: "compiler/sourceMap-StringLiteralWithNewLine.ts" Expect to Parse: "compiler/sourceMapForFunctionInInternalModuleWithCommentPrecedingStatement01.ts" Expect to Parse: "compiler/sourceMapValidationClasses.ts" -Expect to Parse: "compiler/sourceMapValidationDecorators.ts" Expect to Parse: "compiler/sourceMapValidationDestructuringForArrayBindingPattern.ts" Expect to Parse: "compiler/sourceMapValidationDestructuringForArrayBindingPattern2.ts" Expect to Parse: "compiler/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.ts"