diff options
Diffstat (limited to 'third_party/rust/jsparagus-ast')
| -rw-r--r-- | third_party/rust/jsparagus-ast/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/Cargo.toml | 24 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/ast.json | 728 | ||||
| -rwxr-xr-x | third_party/rust/jsparagus-ast/generate_ast.py | 1061 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/arena.rs | 85 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/associated_data.rs | 143 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/dump_generated.rs | 2269 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/lib.rs | 30 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/source_atom_set.rs | 221 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/source_location.rs | 32 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/source_location_accessor_generated.rs | 2047 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/source_slice_list.rs | 49 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/type_id_generated.rs | 712 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/types_generated.rs | 1055 | ||||
| -rw-r--r-- | third_party/rust/jsparagus-ast/src/visit_generated.rs | 5423 |
15 files changed, 13880 insertions, 0 deletions
diff --git a/third_party/rust/jsparagus-ast/.cargo-checksum.json b/third_party/rust/jsparagus-ast/.cargo-checksum.json new file mode 100644 index 0000000000..19ea4f9802 --- /dev/null +++ b/third_party/rust/jsparagus-ast/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"2466efc9f6a05392e65e90a882b7ee0ec50be8213d32a73bcef241f46e892ef0","ast.json":"e9c358aedb77bf02059f44179140d900c705af592069f269022bc9b52dc30ac4","generate_ast.py":"0c24431d9c07af42d7d17739c2e21465964151562437cfca093ceddde898bc93","src/arena.rs":"03ef07c963556160a6f1a85fd901833d7322f8a5f265c20d3e3543432dd2a96d","src/associated_data.rs":"5e0d830b0c6db4dcb85ba21ead87d31cd386e2517804333a6f46a1bd1bf59355","src/dump_generated.rs":"8ca0736952ee41fc932807e8450c6eb68e081b3fd5f7a0f701cae8b35dc0c13e","src/lib.rs":"b35553bedec9f6d88cc5194592f857dc13669559cbc8b206048c35299c4f86be","src/source_atom_set.rs":"24ec99be098cab6aa433d7b2e0a2cbc074204276d6c90b17174e50f8003244ee","src/source_location.rs":"3832440ecec6de726262837072810410bddb45c075288386509511c153f6afd9","src/source_location_accessor_generated.rs":"2669efcc5447229429f8fab6123bbd9dec8ed4c69232992af05aca3a59f1c710","src/source_slice_list.rs":"c82413b3081e091a3c4ce5d2c3624e54ecbeb0bb9952f10d373d10faf589955a","src/type_id_generated.rs":"a1e88f0d9d97d61339d0bedd0f6a8472bd39ea13968531ebce7140ca47edbaeb","src/types_generated.rs":"eda341459f8356dc46a6f8ed993740bcf1536c6b6601d885f2a20f4a7a4d4e4a","src/visit_generated.rs":"90ae82f2db8b33f5b23eae1b1b21f1ce4c14a79719bc46e44a838a04c7d838e4"},"package":null}
\ No newline at end of file diff --git a/third_party/rust/jsparagus-ast/Cargo.toml b/third_party/rust/jsparagus-ast/Cargo.toml new file mode 100644 index 0000000000..b7dbef56d4 --- /dev/null +++ b/third_party/rust/jsparagus-ast/Cargo.toml @@ -0,0 +1,24 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2018" +name = "jsparagus-ast" +version = "0.1.0" +authors = ["khyperia <khyperia@live.com>"] +license = "MIT/Apache-2.0" + +[dependencies] +indexmap = "1.0" + +[dependencies.bumpalo] +version = "3.4.0" +features = ["collections"] diff --git a/third_party/rust/jsparagus-ast/ast.json b/third_party/rust/jsparagus-ast/ast.json new file mode 100644 index 0000000000..669a7b3256 --- /dev/null +++ b/third_party/rust/jsparagus-ast/ast.json @@ -0,0 +1,728 @@ +{ + "Void": { + "_type": "enum" + }, + "Argument": { + "_type": "enum", + "SpreadElement": "Box<Expression>", + "Expression": "Box<Expression>" + }, + "Arguments": { + "_type": "struct", + "args": "Vec<Argument>" + }, + "Identifier": { + "_type": "struct", + "value": "SourceAtomSetIndex" + }, + "IdentifierName": { + "_type": "struct", + "value": "SourceAtomSetIndex" + }, + "PrivateIdentifier": { + "_type": "struct", + "value": "SourceAtomSetIndex" + }, + "Label": { + "_type": "struct", + "value": "SourceAtomSetIndex" + }, + "VariableDeclarationKind": { + "_type": "enum", + "Var": null, + "Let": null, + "Const": null + }, + "CompoundAssignmentOperator": { + "_type": "enum", + "LogicalOr": null, + "LogicalAnd": null, + "Coalesce": null, + "Add": null, + "Sub": null, + "Mul": null, + "Div": null, + "Mod": null, + "Pow": null, + "LeftShift": null, + "RightShift": null, + "RightShiftExt": null, + "Or": null, + "Xor": null, + "And": null + }, + "BinaryOperator": { + "_type": "enum", + "Equals": null, + "NotEquals": null, + "StrictEquals": null, + "StrictNotEquals": null, + "LessThan": null, + "LessThanOrEqual": null, + "GreaterThan": null, + "GreaterThanOrEqual": null, + "In": null, + "Instanceof": null, + "LeftShift": null, + "RightShift": null, + "RightShiftExt": null, + "Add": null, + "Sub": null, + "Mul": null, + "Div": null, + "Mod": null, + "Pow": null, + "Comma": null, + "Coalesce": null, + "LogicalOr": null, + "LogicalAnd": null, + "BitwiseOr": null, + "BitwiseXor": null, + "BitwiseAnd": null + }, + "UnaryOperator": { + "_type": "enum", + "Plus": null, + "Minus": null, + "LogicalNot": null, + "BitwiseNot": null, + "Typeof": null, + "Void": null, + "Delete": null + }, + "UpdateOperator": { + "_type": "enum", + "Increment": null, + "Decrement": null + }, + "Function": { + "_type": "struct", + "name": "Option<BindingIdentifier>", + "is_async": "bool", + "is_generator": "bool", + "params": "FormalParameters", + "body": "FunctionBody" + }, + "Program": { + "_type": "enum", + "Module": "Module", + "Script": "Script" + }, + "IfStatement": { + "_type": "struct", + "test": "Box<Expression>", + "consequent": "Box<Statement>", + "alternate": "Option<Box<Statement>>" + }, + "Statement": { + "_type": "enum", + "BlockStatement": { + "block": "Block" + }, + "BreakStatement": { + "label": "Option<Label>" + }, + "ContinueStatement": { + "label": "Option<Label>" + }, + "DebuggerStatement": null, + "DoWhileStatement": { + "block": "Box<Statement>", + "test": "Box<Expression>" + }, + "EmptyStatement": null, + "ExpressionStatement": "Box<Expression>", + "ForInStatement": { + "left": "VariableDeclarationOrAssignmentTarget", + "right": "Box<Expression>", + "block": "Box<Statement>" + }, + "ForOfStatement": { + "left": "VariableDeclarationOrAssignmentTarget", + "right": "Box<Expression>", + "block": "Box<Statement>" + }, + "ForStatement": { + "init": "Option<VariableDeclarationOrExpression>", + "test": "Option<Box<Expression>>", + "update": "Option<Box<Expression>>", + "block": "Box<Statement>" + }, + "IfStatement": "IfStatement", + "LabelledStatement": { + "label": "Label", + "body": "Box<Statement>" + }, + "ReturnStatement": { + "expression": "Option<Box<Expression>>" + }, + "SwitchStatement": { + "discriminant": "Box<Expression>", + "cases": "Vec<SwitchCase>" + }, + "SwitchStatementWithDefault": { + "discriminant": "Box<Expression>", + "pre_default_cases": "Vec<SwitchCase>", + "default_case": "SwitchDefault", + "post_default_cases": "Vec<SwitchCase>" + }, + "ThrowStatement": { + "expression": "Box<Expression>" + }, + "TryCatchStatement": { + "body": "Block", + "catch_clause": "CatchClause" + }, + "TryFinallyStatement": { + "body": "Block", + "catch_clause": "Option<CatchClause>", + "finalizer": "Block" + }, + "WhileStatement": { + "test": "Box<Expression>", + "block": "Box<Statement>" + }, + "WithStatement": { + "object": "Box<Expression>", + "body": "Box<Statement>" + }, + "VariableDeclarationStatement": "VariableDeclaration", + "FunctionDeclaration": "Function", + "ClassDeclaration": "ClassDeclaration" + }, + "Expression": { + "_type": "enum", + "MemberExpression": "MemberExpression", + "ClassExpression": "ClassExpression", + "LiteralBooleanExpression": { + "value": "bool" + }, + "LiteralInfinityExpression": null, + "LiteralNullExpression": null, + "LiteralNumericExpression": "NumericLiteral", + "LiteralRegExpExpression": { + "pattern": "SourceSliceIndex", + "global": "bool", + "ignore_case": "bool", + "multi_line": "bool", + "dot_all": "bool", + "sticky": "bool", + "unicode": "bool" + }, + "LiteralStringExpression": { + "value": "SourceAtomSetIndex" + }, + "ArrayExpression": "ArrayExpression", + "ArrowExpression": { + "is_async": "bool", + "params": "FormalParameters", + "body": "ArrowExpressionBody" + }, + "AssignmentExpression": { + "binding": "AssignmentTarget", + "expression": "Box<Expression>" + }, + "BinaryExpression": { + "operator": "BinaryOperator", + "left": "Box<Expression>", + "right": "Box<Expression>" + }, + "CallExpression": "CallExpression", + "CompoundAssignmentExpression": { + "operator": "CompoundAssignmentOperator", + "binding": "SimpleAssignmentTarget", + "expression": "Box<Expression>" + }, + "ConditionalExpression": { + "test": "Box<Expression>", + "consequent": "Box<Expression>", + "alternate": "Box<Expression>" + }, + "FunctionExpression": "Function", + "IdentifierExpression": "IdentifierExpression", + "NewExpression": { + "callee": "Box<Expression>", + "arguments": "Arguments" + }, + "NewTargetExpression": null, + "ObjectExpression": "ObjectExpression", + "OptionalExpression": { + "object": "ExpressionOrSuper", + "tail": "Box<Expression>" + }, + "OptionalChain": "OptionalChain", + "UnaryExpression": { + "operator": "UnaryOperator", + "operand": "Box<Expression>" + }, + "TemplateExpression": "TemplateExpression", + "ThisExpression": null, + "UpdateExpression": { + "is_prefix": "bool", + "operator": "UpdateOperator", + "operand": "SimpleAssignmentTarget" + }, + "YieldExpression": { + "expression": "Option<Box<Expression>>" + }, + "YieldGeneratorExpression": { + "expression": "Box<Expression>" + }, + "AwaitExpression": { + "expression": "Box<Expression>" + }, + "ImportCallExpression": { + "argument": "Box<Expression>" + } + }, + "MemberExpression": { + "_type": "enum", + "ComputedMemberExpression": "ComputedMemberExpression", + "StaticMemberExpression": "StaticMemberExpression", + "PrivateFieldExpression": "PrivateFieldExpression" + }, + "OptionalChain": { + "_type": "enum", + "ComputedMemberExpressionTail": { + "expression": "Box<Expression>" + }, + "StaticMemberExpressionTail": { + "property": "IdentifierName" + }, + "PrivateFieldExpressionTail": { + "field": "PrivateIdentifier" + }, + "CallExpressionTail": { + "arguments": "Arguments" + }, + "ComputedMemberExpression": "ComputedMemberExpression", + "StaticMemberExpression": "StaticMemberExpression", + "PrivateFieldExpression": "PrivateFieldExpression", + "CallExpression": "CallExpression" + }, + "PropertyName": { + "_type": "enum", + "ComputedPropertyName": "ComputedPropertyName", + "StaticPropertyName": "StaticPropertyName", + "StaticNumericPropertyName": "NumericLiteral" + }, + "CallExpression": { + "_type": "struct", + "callee": "ExpressionOrSuper", + "arguments": "Arguments" + }, + "ClassElementName": { + "_type": "enum", + "ComputedPropertyName": "ComputedPropertyName", + "StaticPropertyName": "StaticPropertyName", + "StaticNumericPropertyName": "NumericLiteral", + "PrivateFieldName": "PrivateIdentifier" + }, + "ObjectProperty": { + "_type": "enum", + "NamedObjectProperty": "NamedObjectProperty", + "ShorthandProperty": "ShorthandProperty", + "SpreadProperty": "Box<Expression>" + }, + "NamedObjectProperty": { + "_type": "enum", + "MethodDefinition": "MethodDefinition", + "DataProperty": "DataProperty" + }, + "MethodDefinition": { + "_type": "enum", + "Method": "Method", + "Getter": "Getter", + "Setter": "Setter" + }, + "ImportDeclaration": { + "_type": "enum", + "Import": "Import", + "ImportNamespace": "ImportNamespace" + }, + "ExportDeclaration": { + "_type": "enum", + "ExportAllFrom": "ExportAllFrom", + "ExportFrom": "ExportFrom", + "ExportLocals": "ExportLocals", + "Export": "Export", + "ExportDefault": "ExportDefault" + }, + "VariableReference": { + "_type": "enum", + "BindingIdentifier": "BindingIdentifier", + "AssignmentTargetIdentifier": "AssignmentTargetIdentifier" + }, + "BindingPattern": { + "_type": "enum", + "ObjectBinding": "ObjectBinding", + "ArrayBinding": "ArrayBinding" + }, + "Binding": { + "_type": "enum", + "BindingPattern": "BindingPattern", + "BindingIdentifier": "BindingIdentifier" + }, + "SimpleAssignmentTarget": { + "_type": "enum", + "AssignmentTargetIdentifier": "AssignmentTargetIdentifier", + "MemberAssignmentTarget": "MemberAssignmentTarget" + }, + "AssignmentTargetPattern": { + "_type": "enum", + "ArrayAssignmentTarget": "ArrayAssignmentTarget", + "ObjectAssignmentTarget": "ObjectAssignmentTarget" + }, + "AssignmentTarget": { + "_type": "enum", + "AssignmentTargetPattern": "AssignmentTargetPattern", + "SimpleAssignmentTarget": "SimpleAssignmentTarget" + }, + "Parameter": { + "_type": "enum", + "Binding": "Binding", + "BindingWithDefault": "BindingWithDefault" + }, + "BindingWithDefault": { + "_type": "struct", + "binding": "Binding", + "init": "Box<Expression>" + }, + "BindingIdentifier": { + "_type": "struct", + "name": "Identifier" + }, + "AssignmentTargetIdentifier": { + "_type": "struct", + "name": "Identifier" + }, + "ExpressionOrSuper": { + "_type": "enum", + "Expression": "Box<Expression>", + "Super": null + }, + "MemberAssignmentTarget": { + "_type": "enum", + "ComputedMemberAssignmentTarget": "ComputedMemberAssignmentTarget", + "PrivateFieldAssignmentTarget": "PrivateFieldAssignmentTarget", + "StaticMemberAssignmentTarget": "StaticMemberAssignmentTarget" + }, + "ComputedMemberAssignmentTarget": { + "_type": "struct", + "object": "ExpressionOrSuper", + "expression": "Box<Expression>" + }, + "PrivateFieldAssignmentTarget": { + "_type": "struct", + "object": "ExpressionOrSuper", + "field": "PrivateIdentifier" + }, + "StaticMemberAssignmentTarget": { + "_type": "struct", + "object": "ExpressionOrSuper", + "property": "IdentifierName" + }, + "ArrayBinding": { + "_type": "struct", + "elements": "Vec<Option<Parameter>>", + "rest": "Option<Box<Binding>>" + }, + "ObjectBinding": { + "_type": "struct", + "properties": "Vec<BindingProperty>", + "rest": "Option<Box<BindingIdentifier>>" + }, + "BindingProperty": { + "_type": "enum", + "BindingPropertyIdentifier": "BindingPropertyIdentifier", + "BindingPropertyProperty": "BindingPropertyProperty" + }, + "BindingPropertyIdentifier": { + "_type": "struct", + "binding": "BindingIdentifier", + "init": "Option<Box<Expression>>" + }, + "BindingPropertyProperty": { + "_type": "struct", + "name": "PropertyName", + "binding": "Parameter" + }, + "AssignmentTargetWithDefault": { + "_type": "struct", + "binding": "AssignmentTarget", + "init": "Box<Expression>" + }, + "AssignmentTargetMaybeDefault": { + "_type": "enum", + "AssignmentTarget": "AssignmentTarget", + "AssignmentTargetWithDefault": "AssignmentTargetWithDefault" + }, + "ArrayAssignmentTarget": { + "_type": "struct", + "elements": "Vec<Option<AssignmentTargetMaybeDefault>>", + "rest": "Option<Box<AssignmentTarget>>" + }, + "ObjectAssignmentTarget": { + "_type": "struct", + "properties": "Vec<AssignmentTargetProperty>", + "rest": "Option<Box<AssignmentTarget>>" + }, + "AssignmentTargetProperty": { + "_type": "enum", + "AssignmentTargetPropertyIdentifier": "AssignmentTargetPropertyIdentifier", + "AssignmentTargetPropertyProperty": "AssignmentTargetPropertyProperty" + }, + "AssignmentTargetPropertyIdentifier": { + "_type": "struct", + "binding": "AssignmentTargetIdentifier", + "init": "Option<Box<Expression>>" + }, + "AssignmentTargetPropertyProperty": { + "_type": "struct", + "name": "PropertyName", + "binding": "AssignmentTargetMaybeDefault" + }, + "ClassExpression": { + "_type": "struct", + "name": "Option<BindingIdentifier>", + "super_": "Option<Box<Expression>>", + "elements": "Vec<Box<ClassElement>>" + }, + "ClassDeclaration": { + "_type": "struct", + "name": "BindingIdentifier", + "super_": "Option<Box<Expression>>", + "elements": "Vec<Box<ClassElement>>" + }, + "ClassElement": { + "_type": "enum", + "MethodDefinition": { + "is_static": "bool", + "method": "MethodDefinition" + }, + "FieldDefinition": { + "name": "ClassElementName", + "init": "Option<Box<Expression>>" + } + }, + "ModuleItems": { + "_type": "enum", + "ImportDeclaration": "ImportDeclaration", + "ExportDeclaration": "ExportDeclaration", + "Statement": "Box<Statement>" + }, + "Module": { + "_type": "struct", + "directives": "Vec<Directive>", + "items": "Vec<ModuleItems>" + }, + "Import": { + "_type": "struct", + "module_specifier": "SourceAtomSetIndex", + "default_binding": "Option<BindingIdentifier>", + "named_imports": "Vec<ImportSpecifier>" + }, + "ImportNamespace": { + "_type": "struct", + "module_specifier": "SourceAtomSetIndex", + "default_binding": "Option<BindingIdentifier>", + "namespace_binding": "BindingIdentifier" + }, + "ImportSpecifier": { + "_type": "struct", + "name": "Option<IdentifierName>", + "binding": "BindingIdentifier" + }, + "ExportAllFrom": { + "_type": "struct", + "module_specifier": "SourceAtomSetIndex" + }, + "ExportFrom": { + "_type": "struct", + "named_exports": "Vec<ExportFromSpecifier>", + "module_specifier": "SourceAtomSetIndex" + }, + "ExportLocals": { + "_type": "struct", + "named_exports": "Vec<ExportLocalSpecifier>" + }, + "Export": { + "_type": "enum", + "FunctionDeclaration": "Function", + "ClassDeclaration": "ClassDeclaration", + "VariableDeclaration": "VariableDeclaration" + }, + "ExportDefault": { + "_type": "enum", + "FunctionDeclaration": "Function", + "ClassDeclaration": "ClassDeclaration", + "Expression": "Box<Expression>" + }, + "ExportFromSpecifier": { + "_type": "struct", + "name": "IdentifierName", + "exported_name": "Option<IdentifierName>" + }, + "ExportLocalSpecifier": { + "_type": "struct", + "name": "IdentifierExpression", + "exported_name": "Option<IdentifierName>" + }, + "Method": { + "_type": "struct", + "name": "ClassElementName", + "is_async": "bool", + "is_generator": "bool", + "params": "FormalParameters", + "body": "FunctionBody" + }, + "Getter": { + "_type": "struct", + "property_name": "ClassElementName", + "body": "FunctionBody" + }, + "Setter": { + "_type": "struct", + "property_name": "ClassElementName", + "param": "Parameter", + "body": "FunctionBody" + }, + "DataProperty": { + "_type": "struct", + "property_name": "PropertyName", + "expression": "Box<Expression>" + }, + "ShorthandProperty": { + "_type": "struct", + "name": "IdentifierExpression" + }, + "ComputedPropertyName": { + "_type": "struct", + "expression": "Box<Expression>" + }, + "StaticPropertyName": { + "_type": "struct", + "value": "SourceAtomSetIndex" + }, + "NumericLiteral": { + "_type": "struct", + "value": "f64" + }, + "ArrayExpressionElement": { + "_type": "enum", + "SpreadElement": "Box<Expression>", + "Expression": "Box<Expression>", + "Elision": null + }, + "ArrayExpression": { + "_type": "struct", + "elements": "Vec<ArrayExpressionElement>" + }, + "ArrowExpressionBody": { + "_type": "enum", + "FunctionBody": "FunctionBody", + "Expression": "Box<Expression>" + }, + "ComputedMemberExpression": { + "_type": "struct", + "object": "ExpressionOrSuper", + "expression": "Box<Expression>" + }, + "IdentifierExpression": { + "_type": "struct", + "name": "Identifier" + }, + "ObjectExpression": { + "_type": "struct", + "properties": "Vec<Box<ObjectProperty>>" + }, + "StaticMemberExpression": { + "_type": "struct", + "object": "ExpressionOrSuper", + "property": "IdentifierName" + }, + "PrivateFieldExpression": { + "_type": "struct", + "object": "ExpressionOrSuper", + "field": "PrivateIdentifier" + }, + "TemplateExpressionElement": { + "_type": "enum", + "Expression": "Box<Expression>", + "TemplateElement": "TemplateElement" + }, + "TemplateExpression": { + "_type": "struct", + "tag": "Option<Box<Expression>>", + "elements": "Vec<TemplateExpressionElement>" + }, + "VariableDeclarationOrAssignmentTarget": { + "_type": "enum", + "VariableDeclaration": "VariableDeclaration", + "AssignmentTarget": "AssignmentTarget" + }, + "VariableDeclarationOrExpression": { + "_type": "enum", + "VariableDeclaration": "VariableDeclaration", + "Expression": "Box<Expression>" + }, + "Block": { + "_type": "struct", + "statements": "Vec<Statement>", + "declarations": "Option<Vec<SourceAtomSetIndex>>" + }, + "CatchClause": { + "_type": "struct", + "binding": "Option<Box<Binding>>", + "body": "Block" + }, + "Directive": { + "_type": "struct", + "raw_value": "SourceAtomSetIndex" + }, + "FormalParameters": { + "_type": "struct", + "items": "Vec<Parameter>", + "rest": "Option<Binding>" + }, + "FunctionBody": { + "_type": "struct", + "directives": "Vec<Directive>", + "statements": "Vec<Statement>" + }, + "Script": { + "_type": "struct", + "directives": "Vec<Directive>", + "statements": "Vec<Statement>" + }, + "SwitchCase": { + "_type": "struct", + "test": "Box<Expression>", + "consequent": "Vec<Statement>" + }, + "SwitchDefault": { + "_type": "struct", + "consequent": "Vec<Statement>" + }, + "TemplateElement": { + "_type": "struct", + "raw_value": "SourceAtomSetIndex" + }, + "VariableDeclaration": { + "_type": "struct", + "kind": "VariableDeclarationKind", + "declarators": "Vec<VariableDeclarator>" + }, + "VariableDeclarator": { + "_type": "struct", + "binding": "Binding", + "init": "Option<Box<Expression>>" + }, + "CoverParenthesized": { + "_type": "enum", + "Expression": { + "expression": "Box<Expression>" + }, + "Parameters": "Box<FormalParameters>" + } +} diff --git a/third_party/rust/jsparagus-ast/generate_ast.py b/third_party/rust/jsparagus-ast/generate_ast.py new file mode 100755 index 0000000000..dab3f96aac --- /dev/null +++ b/third_party/rust/jsparagus-ast/generate_ast.py @@ -0,0 +1,1061 @@ +#!/usr/bin/env python3 + +import json +import os +import re +import collections +import textwrap + + +RUST_BUILTIN_TYPES = { + 'bool', + 'f64', +} + +RUST_PARAMETERIZED_TYPES = { + 'Option', + 'Vec', +} + + +# name is a string; params is a tuple of 0 or more Types. +TypeBase = collections.namedtuple("Type", "name params") + + +class Type(TypeBase): + def __new__(cls, name, params=()): + params = tuple(params) + for p in params: + if not isinstance(p, Type): + raise ValueError("type parameters must be types, got {!r}".format(p)) + return TypeBase.__new__(cls, name, params) + + def __str__(self): + if self.params == (): + return self.name + return self.name + "<{}>".format(", ".join(map(str, self.params))) + + def __repr__(self): + if self.params == (): + return 'Type({!r})'.format(self.name) + return 'Type({!r}, {!r})'.format(self.name, list(self.params)) + + def to_rust_type(self, ast): + params_str = ", ".join(p.to_rust_type(ast) for p in self.params) + if self.name == 'Option': + return "Option<{}>".format(params_str) + if self.name == 'Box': + return "arena::Box<'alloc, {}>".format(params_str) + if self.name == 'Vec': + return "arena::Vec<'alloc, {}>".format(params_str) + if self.name in RUST_PARAMETERIZED_TYPES: + return "{}<{}>".format(self.name, params_str) + if self.params: + return "{}<'alloc, {}>".format(self.name, params_str) + if self.name in RUST_BUILTIN_TYPES: + return self.name + if self.name == 'Token': + return "Token" + if self.name in ast.type_decls and ast.type_decls[self.name].has_lifetime: + return "{}<'alloc>".format(self.name) + return self.name + + def rust_variant_name(self): + if self.name == 'Vec': + return 'Vec' + self.params[0].rust_variant_name() + if self.name == 'Box': + return self.params[0].rust_variant_name() + return self.name + + +def parse_type(ty): + """Parse a type, in the minilanguage used by ast.json, into a Type object. + + A simple type like String parses as `Type("String", ())`; a parameterized type + like `Vec<String>` parses as `Type("Vec", ("String",))`; + nested parameterized types parse as nested Type objects. + """ + ident_re = re.compile(r'^(?:\w|_)+$') + token_re = re.compile(r'(?s)\s*((?:\w|_)+|.)\s*') + tokens = token_re.finditer(ty) + + current = None + + def consume(token=None): + nonlocal current + assert token is None or token == current + current = next(tokens, None) + if current is not None: + current = current.group(1) + + consume(None) # load the first token into `current` + + def is_ident(): + """True if the current token is an identifier""" + return current is not None and ident_re.match(current) is not None + + def parse_params(): + params = [] + while current != '>': + params.append(parse_ty()) + if current == ',': + consume(',') + return params + + def parse_ty(): + if not is_ident(): + raise ValueError("parse error in type {!r}".format(ty)) + name = current + consume() + if current == '<': + consume('<') + params = parse_params() + if current != '>': + raise ValueError("parse error in type {!r} (expected `>`)".format(ty)) + consume('>') + return Type(name, params) + return Type(name) + + result = parse_ty() + if current is not None: + raise ValueError("parse error in type {!r} (extra stuff at end)".format(ty)) + return result + + +assert parse_type('Statement') == Type('Statement') +assert parse_type('Box<T>') == Type('Box', [Type('T')]) +assert parse_type("Vec<Box<Expression>>") == Type('Vec', [Type('Box', [Type('Expression')])]) + + +def write_impl(f, indentation, string, *format_args): + if len(format_args) == 0: + formatted = string + if '\n' in formatted: + cut = formatted.rindex("\n") + if formatted[cut:].isspace(): + formatted = formatted[:cut] + formatted = textwrap.dedent(formatted.rstrip()) + else: + formatted = string.format(*format_args) + f.write(" " * indentation + formatted + "\n") + + +def to_snek_case(ident): + # https://stackoverflow.com/questions/1175208 + s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', ident) + return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower() + + +EXTRA_STACK_VALUE_TYPE_NAMES = [ + "Token", + "Vec<SwitchCase>", + "Vec<Statement>", + "Vec<VariableDeclarator>", + "Vec<ArrayExpressionElement>", + "Vec<Box<ClassElement>>", + "Vec<BindingProperty>", + "Vec<Option<Parameter>>", +] + + +def collect_stack_value_types(ast): + types = {} + for name, type_decl in ast.type_decls.items(): + ty = parse_type(name) + if ty in types: + raise ValueError("type occurs twice with different spellings: {!r} and {!r}" + .format(name, types[ty])) + types[ty] = name + + types = set(types.keys()) + for name in EXTRA_STACK_VALUE_TYPE_NAMES: + types.add(parse_type(name)) + + return sorted(types) + + +def stack_value(ast): + types = collect_stack_value_types(ast) + with open("../generated_parser/src/stack_value_generated.rs", "w+") as f: + def write(*args): + write_impl(f, *args) + write(0, """\ + // WARNING: This file is auto-generated by crates/ast/generate_ast.py. + + use crate::token::Token; + use ast::arena; + use ast::types::*; + use std::convert::Infallible; + + pub type AstError = String; + type AstResult<'alloc, T> = Result<arena::Box<'alloc, T>, AstError>; + + #[derive(Debug)] + pub enum StackValue<'alloc> { + """) + + for ty in types: + write(1, "{}({}),", ty.rust_variant_name(), Type('Box', [ty]).to_rust_type(ast)) + + write(0, """\ + } + + impl<'alloc> StackValue<'alloc> { + pub fn to_ast<T: StackValueItem<'alloc>>(self) -> AstResult<'alloc, T> { + T::to_ast(self) + } + } + + pub trait StackValueItem<'alloc>: Sized { + fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self>; + } + + /// Values that can be converted to StackValues, fallibly. + pub trait TryIntoStack<'alloc> { + type Error; + fn try_into_stack(self) -> Result<StackValue<'alloc>, Self::Error>; + } + """) + + for ty in types: + write(0, "impl<'alloc> StackValueItem<'alloc> for {} {{", ty.to_rust_type(ast)) + write(1, "fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {") + write(2, "match sv {") + write(3, "StackValue::{}(v) => Ok(v),", ty.rust_variant_name()) + write(3, "_ => Err(format!(\"StackValue expected {}, got {{:?}}\", sv)),", ty) + write(2, "}") + write(1, "}") + write(0, "}") + write(0, "") + for ty in types: + rust_ty = ty.to_rust_type(ast) + write(0, "impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, {}> {{", rust_ty) + write(1, "type Error = Infallible;") + write(1, "fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {") + write(2, "Ok(StackValue::{}(self))", ty.rust_variant_name()) + write(1, "}") + write(0, "}") + write(0, "") + write(0, """\ + impl<'alloc, T, E> TryIntoStack<'alloc> for Result<T, E> + where + T: TryIntoStack<'alloc>, + E: From<T::Error>, + { + type Error = E; + fn try_into_stack(self) -> Result<StackValue<'alloc>, E> { + Ok(self?.try_into_stack()?) + } + } + """) + + +def loc_trait(ast): + types = collect_stack_value_types(ast) + with open("src/source_location_accessor_generated.rs", "w+") as f: + def write(*args): + write_impl(f, *args) + write(0, """\ + // WARNING: This file is auto-generated by crates/ast/generate_ast.py. + + use crate::SourceLocation; + use crate::arena; + use crate::types::*; + use std::borrow::{Borrow, BorrowMut}; + + pub trait SourceLocationAccessor { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation); + fn get_loc(&self) -> SourceLocation; + } + + """) + + extra_types = [] + + def define_accessor(ty): + if ty.name in ['Box', 'Token', 'Vec', 'Void']: + return + + if ty.name not in ast.type_decls: + raise ValueError("unhandlable type {!r}".format(ty.name)) + + rust_ty = ty.to_rust_type(ast) + decl = ast.type_decls[ty.name] + + write(0, "impl<'alloc> SourceLocationAccessor for {} {{", rust_ty) + if isinstance(decl, Struct): + write(1, "fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) {") + write(2, "self.loc.start = start.start;") + write(2, "self.loc.end = end.end;") + write(1, "}") + write(0, "") + write(1, "fn get_loc(&self) -> SourceLocation {") + write(2, "self.loc") + write(1, "}") + elif isinstance(decl, Enum): + write(1, "fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) {") + write(2, "match self {") + for variant_name, variant_ty in decl.variants.items(): + if variant_ty is None: + write(3, "{}::{} {{ mut loc }} => {{", ty.name, variant_name) + write(4, "loc.start = start.start;") + write(4, "loc.end = end.end;") + write(3, "}}", ty.name, variant_name) + elif isinstance(variant_ty, dict): + write(3, "{}::{} {{ mut loc, .. }} => {{", ty.name, variant_name) + write(4, "loc.start = start.start;") + write(4, "loc.end = end.end;") + write(3, "}") + else: + write(3, "{}::{}(content) => {{ content.set_loc(start, end) }}", + ty.name, variant_name) + if variant_ty not in extra_types and variant_ty not in types: + extra_types.append(variant_ty) + write(2, "}") + write(1, "}") + write(0, "") + write(1, "fn get_loc(&self) -> SourceLocation {") + write(2, "match self {") + for variant_name, variant_ty in decl.variants.items(): + if variant_ty is None: + write(3, "{}::{} {{ loc }} => {{", ty.name, variant_name) + write(4, "*loc") + write(3, "}}", ty.name, variant_name) + elif isinstance(variant_ty, dict): + write(3, "{}::{} {{ loc, .. }} => {{", ty.name, variant_name) + write(4, "*loc") + write(3, "}") + else: + write(3, "{}::{}(content) => {{ content.get_loc() }}", + ty.name, variant_name) + write(2, "}") + write(1, "}") + else: + raise ValueError("unhandlable type {!r}".format(types[ty])) + + write(0, "}") + write(0, "") + + for ty in types: + define_accessor(ty) + + for ty in extra_types: + define_accessor(ty) + + write(0, "impl<'alloc, T> SourceLocationAccessor for arena::Box<'alloc, T>") + write(0, "where") + write(1, "T: SourceLocationAccessor,") + write(0, "{") + write(1, "fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) {") + write(2, "(self.borrow_mut() as &mut T).set_loc(start, end)") + write(1, "}") + write(0, "") + write(1, "fn get_loc(&self) -> SourceLocation {") + write(2, "(self.borrow() as &T).get_loc()") + write(1, "}") + write(0, "}") + + +def pass_(ast): + with open("src/visit_generated.rs", "w+") as f: + def write(*args): + write_impl(f, *args) + + def to_method_name(name): + return "visit_{}".format(to_snek_case(name)) + + def to_enum_method_name(enum_name, variant_name): + return "visit_enum_{}_variant_{}".format(to_snek_case(enum_name), + to_snek_case(variant_name)) + + def to_enter_method_name(name): + return "enter_{}".format(to_snek_case(name)) + + def to_enter_enum_method_name(enum_name, variant_name): + return "enter_enum_{}_variant_{}".format(to_snek_case(enum_name), + to_snek_case(variant_name)) + + def to_leave_method_name(name): + return "leave_{}".format(to_snek_case(name)) + + def to_leave_enum_method_name(enum_name, variant_name): + return "leave_enum_{}_variant_{}".format(to_snek_case(enum_name), + to_snek_case(variant_name)) + + # --- Pass --- + + def emit_call(indent, ty, var): + if ty.name == 'Vec': + write(indent, "for item in {} {{", var) + emit_call(indent + 1, ty.params[0], "item") + write(indent, "}") + elif ty.name == 'Option': + write(indent, "if let Some(item) = {} {{", var) + emit_call(indent + 1, ty.params[0], "item") + write(indent, "}") + elif ty.name in RUST_BUILTIN_TYPES: + pass + elif ty.name == "SourceAtomSetIndex": + pass + elif ty.name == "SourceSliceIndex": + pass + elif ty.name == 'Box': + write(indent, "self.{}({});", to_method_name(ty.params[0].name), var) + else: + write(indent, "self.{}({});", to_method_name(ty.name), var) + + def emit_variant_dict_call(indent, enum_name, variant_name, + variant_type): + write(indent, "self.{}(", + to_enum_method_name(enum_name, variant_name)) + for field_name, field_ty in variant_type.items(): + write(indent + 1, "{},", field_name) + write(indent, ")") + + def emit_variant_tuple_call(indent, enum_name, variant_name, param): + write(indent, "self.{}({})", + to_enum_method_name(enum_name, variant_name), + param) + + def emit_variant_none_call(indent, enum_name, variant_name): + write(indent, "self.{}()", + to_enum_method_name(enum_name, variant_name)) + + write(0, "// WARNING: This file is auto-generated.") + write(0, "") + write(0, "#![allow(unused_mut)]") + write(0, "#![allow(unused_parens)]") + write(0, "#![allow(unused_variables)]") + write(0, "#![allow(dead_code)]") + write(0, "") + write(0, "use crate::arena;") + write(0, "use crate::source_atom_set::SourceAtomSetIndex;") + write(0, "use crate::source_slice_list::SourceSliceIndex;") + write(0, "use crate::types::*;") + write(0, "") + write(0, "pub trait Pass<'alloc> {") + for name, type_decl in ast.type_decls.items(): + if name == "Void": + # Hack in a quick fix + continue + + write(1, "fn {}(&mut self, ast: &'alloc {}) {{", + to_method_name(type_decl.name), Type(name).to_rust_type(ast)) + + write(2, "self.{}(ast);", + to_enter_method_name(type_decl.name)) + + type_decl.write_rust_pass_method_body(write, emit_call, + emit_variant_dict_call, + emit_variant_tuple_call, + emit_variant_none_call) + + write(2, "self.{}(ast);", + to_leave_method_name(type_decl.name)) + + write(1, "}") + write(0, "") + + write(1, "fn {}(&mut self, ast: &'alloc {}) {{", + to_enter_method_name(type_decl.name), + Type(name).to_rust_type(ast)) + write(1, "}") + write(0, "") + + write(1, "fn {}(&mut self, ast: &'alloc {}) {{", + to_leave_method_name(type_decl.name), + Type(name).to_rust_type(ast)) + write(1, "}") + write(0, "") + + if isinstance(type_decl, Enum): + for variant_name, variant_type in type_decl.variants.items(): + if variant_type is None: + write(1, "fn {}(&mut self) {{", + to_enum_method_name(type_decl.name, + variant_name)), + write(1, "}") + write(0, "") + elif isinstance(variant_type, dict): + def write_field_params(indent, write, variant_type, + ast): + for field_name, field_ty in variant_type.items(): + write(2, "{}: &'alloc {},", + field_name, field_ty.to_rust_type(ast)) + + write(1, "fn {}(", + to_enum_method_name(type_decl.name, + variant_name)), + write(2, "&mut self,") + write_field_params(2, write, variant_type, ast) + write(1, ") {") + + write(2, "self.{}(", + to_enter_enum_method_name(type_decl.name, + variant_name)) + for field_name, field_ty in variant_type.items(): + write(3, "{},", field_name) + write(2, ");") + + type_decl.write_rust_pass_variant_dict_method_body( + emit_call, variant_type) + + write(2, "self.{}(", + to_leave_enum_method_name(type_decl.name, + variant_name)) + for field_name, field_ty in variant_type.items(): + write(3, "{},", field_name) + write(2, ");") + + write(1, "}") + write(0, "") + + write(1, "fn {}(", + to_enter_enum_method_name(type_decl.name, + variant_name)) + write(2, "&mut self,") + write_field_params(2, write, variant_type, ast) + write(1, ") {") + write(1, "}") + write(0, "") + + write(1, "fn {}(", + to_leave_enum_method_name(type_decl.name, + variant_name)) + write(2, "&mut self,") + write_field_params(2, write, variant_type, ast) + write(1, ") {") + write(1, "}") + write(0, "") + else: + def write_field_params(indent, write, variant_type, + ast): + write(2, "ast: &'alloc {},", + variant_type.to_rust_type(ast)) + + write(1, "fn {}(", + to_enum_method_name(type_decl.name, + variant_name)), + write(2, "&mut self,") + write_field_params(2, write, variant_type, ast) + write(1, ") {") + + write(2, "self.{}(ast);", + to_enter_enum_method_name(type_decl.name, + variant_name)) + + type_decl.write_rust_pass_variant_tuple_method_body( + emit_call, variant_type, "ast") + + write(2, "self.{}(ast);", + to_leave_enum_method_name(type_decl.name, + variant_name)) + + write(1, "}") + write(0, "") + + write(1, "fn {}(", + to_enter_enum_method_name(type_decl.name, + variant_name)) + write(2, "&mut self,") + write_field_params(2, write, variant_type, ast) + write(1, ") {") + write(1, "}") + write(0, "") + + write(1, "fn {}(", + to_leave_enum_method_name(type_decl.name, + variant_name)) + write(2, "&mut self,") + write_field_params(2, write, variant_type, ast) + write(1, ") {") + write(1, "}") + write(0, "") + + write(0, "}") + write(0, "") + + +def ast_(ast): + with open("src/types_generated.rs", "w+") as f: + def write(*args): + write_impl(f, *args) + write(0, "// WARNING: This file is auto-generated.") + write(0, "") + write(0, "use crate::source_location::SourceLocation;") + write(0, "use crate::arena;") + write(0, "use crate::source_atom_set::SourceAtomSetIndex;") + write(0, "use crate::source_slice_list::SourceSliceIndex;") + write(0, "") + for type_decl in ast.type_decls.values(): + type_decl.write_rust_type_decl(ast, write) + + +def type_id(ast): + with open("src/type_id_generated.rs", "w+") as f: + def write(*args): + write_impl(f, *args) + write(0, "// WARNING: This file is auto-generated.") + write(0, "") + write(0, "use crate::types::*;") + write(0, "") + + write(0, "#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]") + write(0, "pub enum NodeTypeId {") + + for type_decl in ast.type_decls.values(): + if type_decl.name in ['Box', 'Token', 'Vec', 'Void']: + continue + + write(1, "{},", type_decl.name) + + write(0, "}") + write(0, "") + + write(0, "pub trait NodeTypeIdAccessor {") + write(1, "fn get_type_id(&self) -> NodeTypeId;") + write(0, "}") + write(0, "") + + for type_decl in ast.type_decls.values(): + if type_decl.name in ['Box', 'Token', 'Vec', 'Void']: + continue + + write(0, "impl<'alloc> NodeTypeIdAccessor for {}{} {{", + type_decl.name, + type_decl.lifetime_params()) + write(1, "fn get_type_id(&self) -> NodeTypeId {") + write(2, "NodeTypeId::{}", type_decl.name) + write(1, "}") + write(0, "}") + write(0, "") + + +def dump(ast): + with open('src/dump_generated.rs', 'w+') as f: + def write(*args): + write_impl(f, *args) + + write(0, """\ + // WARNING: This file is auto-generated by crates/ast/generate_ast.py. + + #![allow(unused_variables)] + + use crate::arena; + use crate::source_atom_set::{SourceAtomSet, SourceAtomSetIndex}; + use crate::source_slice_list::{SourceSliceList, SourceSliceIndex}; + use crate::types::*; + use std::ops::Deref; + use std::io; + + fn newline<W>(out: &mut W, depth: usize) + where + W: io::Write, + { + writeln!(out, "").expect("failed to dump"); + for i in 0..depth { + write!(out, " ").expect("failed to dump"); + } + } + + pub trait ASTDump { + fn dump_with_atoms<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList + ) + where + W: io::Write, + { + self.dump_with_atoms_at(out, atoms, slices, 0); + writeln!(out, "").expect("failed to dump"); + } + + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where W: io::Write; + } + """) + + for type_decl in ast.type_decls.values(): + if type_decl.name in ['Box', 'Token', 'Vec', 'Void']: + continue + + write(0, 'impl<\'alloc> ASTDump for {}{} {{', + type_decl.name, + type_decl.lifetime_params()) + write(1, + 'fn dump_with_atoms_at<W>(&self, out: &mut W, ' + 'atoms: &SourceAtomSet, slices: &SourceSliceList, ' + 'depth: usize)') + write(2, 'where W: io::Write') + write(1, '{') + + type_decl.write_rust_dump_method_body(write) + write(1, '}') + write(0, '}') + write(0, '') + + write(0, """\ + impl<'alloc, T> ASTDump for arena::Vec<'alloc, T> + where + T: ASTDump, + { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + write!(out, "[").expect("failed to dump"); + if self.len() > 0 { + for item in self { + newline(out, depth + 1); + item.dump_with_atoms_at(out, atoms, slices, depth + 1); + } + newline(out, depth); + } + write!(out, "]").expect("failed to dump"); + } + } + + impl<T> ASTDump for Option<T> + where + T: ASTDump, + { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + match self { + Some(v) => { + v.dump_with_atoms_at(out, atoms, slices, depth); + } + None => { + write!(out, "None").expect("failed to dump"); + } + } + } + } + + impl<'alloc, T> ASTDump for arena::Box<'alloc, T> + where + T: ASTDump, + { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + self.deref().dump_with_atoms_at(out, atoms, slices, depth); + } + } + + impl ASTDump for bool { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + if *self { + write!(out, "true").expect("failed to dump"); + } else { + write!(out, "false").expect("failed to dump"); + } + } + } + + impl ASTDump for SourceAtomSetIndex { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + write!(out, "{:?}", atoms.get(self.clone())) + .expect("failed to dump"); + } + } + + impl ASTDump for SourceSliceIndex { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + write!(out, "{:?}", slices.get(self.clone())) + .expect("failed to dump"); + } + } + + impl ASTDump for f64 { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + write!(out, "{}", self).expect("failed to dump"); + } + } + """) + + +class AggregateTypeDecl: + def __init__(self): + self.has_lifetime = None + + def lifetime_params(self): + if self.has_lifetime: + return "<'alloc>" + return "" + + +class Struct(AggregateTypeDecl): + def __init__(self, name, struct_json): + AggregateTypeDecl.__init__(self) + self.name = name + self.fields = { + name: parse_type(ty) + for name, ty in struct_json.items() + if name != '_type' + } + + def field_types(self): + return iter(self.fields.values()) + + def write_rust_type_decl(self, ast, write): + if len(self.fields) == 0: + write(0, "#[derive(Default, Debug, PartialEq)]") + else: + write(0, "#[derive(Debug, PartialEq)]") + lifetime_params = self.lifetime_params() + write(0, "pub struct {}{} {{", self.name, lifetime_params) + for field, field_type in self.fields.items(): + write(1, "pub {}: {},", field, field_type.to_rust_type(ast)) + write(1, "pub loc: SourceLocation,") + write(0, "}") + write(0, "") + + def write_rust_pass_method_body(self, write, emit_call, + emit_variant_dict_call, + emit_variant_tuple_call, + emit_variant_none_call): + for name, ty in self.fields.items(): + emit_call(2, ty, "&ast.{}".format(name)) + + def write_rust_dump_method_body(self, write): + write(2, 'write!(out, "({}").expect("failed to dump");', self.name) + for name, ty in self.fields.items(): + if len(self.fields.items()) > 1: + write(2, 'newline(out, depth + 1);') + else: + write(2, 'write!(out, " ").expect("failed to dump");') + write(2, 'write!(out, "{}=").expect("failed to dump");', name) + write(2, 'self.{}.dump_with_atoms_at(out, atoms, slices, depth + 1);', name) + write(2, 'write!(out, ")").expect("failed to dump");') + + +class Enum(AggregateTypeDecl): + def __init__(self, name, enum_json): + AggregateTypeDecl.__init__(self) + + def parse_maybe_type(ty): + if ty is None: + return None + if isinstance(ty, dict): + return {name: parse_type(field_ty) for name, field_ty in ty.items()} + return parse_type(ty) + + self.name = name + self.variants = { + name: parse_maybe_type(ty) + for name, ty in enum_json.items() + if name != '_type' + } + self.has_lifetime = None + + def field_types(self): + for var in self.variants.values(): + if isinstance(var, dict): + yield from var.values() + else: + yield var + + def write_rust_type_decl(self, ast, write): + write(0, "#[derive(Debug, PartialEq)]") + lifetime_params = self.lifetime_params() + write(0, "pub enum {}{} {{", self.name, lifetime_params) + for variant_name, ty in self.variants.items(): + if ty is None: + write(1, "{} {{", variant_name) + write(2, "loc: SourceLocation,") + write(1, "},") + elif isinstance(ty, dict): + write(1, "{} {{", variant_name) + for field_name, field_ty in ty.items(): + write(2, "{}: {},", field_name, field_ty.to_rust_type(ast)) + write(2, "loc: SourceLocation,") + write(1, "},") + else: + write(1, "{}({}),", variant_name, ty.to_rust_type(ast)) + write(0, "}") + write(0, "") + + def write_rust_pass_method_body(self, write, emit_call, + emit_variant_dict_call, + emit_variant_tuple_call, + emit_variant_none_call): + write(2, "match ast {") + for variant_name, variant_type in self.variants.items(): + if variant_type is None: + write(3, "{}::{} {{ .. }} => {{", self.name, variant_name) + emit_variant_none_call(4, self.name, variant_name) + write(3, "}") + elif isinstance(variant_type, dict): + write(3, "{}::{} {{ {}, .. }} => {{", + self.name, variant_name, ', '.join(variant_type.keys())) + emit_variant_dict_call(4, self.name, variant_name, variant_type) + write(3, "}") + else: + write(3, "{}::{}(ast) => {{", self.name, variant_name) + emit_variant_tuple_call(4, self.name, variant_name, "ast") + write(3, "}") + write(2, "}") + + def write_rust_pass_variant_dict_method_body(self, emit_call, + variant_type): + for field_name, field_ty in variant_type.items(): + if field_ty.name == 'Vec': + emit_call(2, field_ty, '{}.iter()'.format(field_name)) + else: + emit_call(2, field_ty, field_name) + + def write_rust_pass_variant_tuple_method_body(self, emit_call, + variant_type, param): + emit_call(2, variant_type, param) + + def write_rust_dump_method_body(self, write): + write(2, 'match self {') + for variant_name, variant_type in self.variants.items(): + if variant_type is None: + write(3, '{}::{} {{ .. }} => {{', self.name, variant_name) + write(4, 'write!(out, "{}").expect("failed to dump");', variant_name) + write(3, '}') + elif isinstance(variant_type, dict): + write(3, '{}::{} {{ {}, .. }} => {{', + self.name, variant_name, ', '.join(variant_type.keys())) + write(4, 'write!(out, "({}").expect("failed to dump");', variant_name) + + for field_name, field_ty in variant_type.items(): + if len(variant_type.items()) > 1: + write(4, 'newline(out, depth + 1);') + else: + write(4, 'write!(out, " ").expect("failed to dump");') + write(4, 'write!(out, "{}=").expect("failed to dump");', field_name) + write(4, '{}.dump_with_atoms_at(out, atoms, slices, depth + 1);', field_name) + + write(4, 'write!(out, ")").expect("failed to dump");') + write(3, '}') + else: + write(3, '{}::{}(ast) => {{', self.name, variant_name) + write(4, 'ast.dump_with_atoms_at(out, atoms, slices, depth);') + write(3, '}') + write(2, '}') + + +class Ast: + def __init__(self, ast_json): + self.type_decls = {} + for name, contents in ast_json.items(): + _type = contents["_type"] + if _type == "struct": + t = Struct(name, contents) + elif _type == "enum": + t = Enum(name, contents) + else: + raise ValueError("unrecognized _type: " + repr(_type)) + self.type_decls[name] = t + + for name in self.type_decls: + self._has_lifetime(name) + + def _has_lifetime(self, name): + ty = self.type_decls[name] + if ty.has_lifetime == "computing": + raise ValueError("invalid AST structure: {} contains itself. Try adding a Box." + .format(name)) + if ty.has_lifetime is None: + ty.has_lifetime = "computing" + ty.has_lifetime = any( + field_ty is not None and self.type_has_lifetime(field_ty) + for field_ty in ty.field_types() + ) + return ty.has_lifetime + + def type_has_lifetime(self, ty): + return ( + ty is not None + and (ty.name == 'Box' + or ty.name == 'Vec' + or any(self.type_has_lifetime(u) + for u in ty.params) + or (ty.name in self.type_decls + and self._has_lifetime(ty.name)))) + + +def main(): + with open("ast.json", "r") as json_file: + ast_json = json.load(json_file) + ast = Ast(ast_json) + + ast_(ast) + type_id(ast) + stack_value(ast) + loc_trait(ast) + pass_(ast) + dump(ast) + + +if __name__ == "__main__": + os.chdir(os.path.dirname(os.path.abspath(__file__))) + main() diff --git a/third_party/rust/jsparagus-ast/src/arena.rs b/third_party/rust/jsparagus-ast/src/arena.rs new file mode 100644 index 0000000000..5c1abdbe86 --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/arena.rs @@ -0,0 +1,85 @@ +use bumpalo::Bump; + +use std::{ + self, + fmt::{self, Debug, Formatter}, + ops, ptr, +}; + +pub use bumpalo::collections::{String, Vec}; + +pub struct Box<'alloc, T: ?Sized>(&'alloc mut T); + +impl<'alloc, T> Box<'alloc, T> { + pub fn unbox(self) -> T { + // This pointer read is safe because the reference `self.0` is + // guaranteed to be unique--not just now, but we're guaranteed it's not + // borrowed from some other reference. This in turn is because we never + // construct an alloc::Box with a borrowed reference, only with a fresh + // one just allocated from a Bump. + unsafe { ptr::read(self.0 as *mut T) } + } +} + +impl<'alloc, T: ?Sized> ops::Deref for Box<'alloc, T> { + type Target = T; + + fn deref(&self) -> &T { + self.0 + } +} + +impl<'alloc, T: ?Sized> ops::DerefMut for Box<'alloc, T> { + fn deref_mut(&mut self) -> &mut T { + self.0 + } +} + +impl<'alloc, T: ?Sized> Debug for Box<'alloc, T> +where + T: Debug, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl<'alloc, T> PartialEq for Box<'alloc, T> +where + T: PartialEq<T> + ?Sized, +{ + fn eq(&self, other: &Box<'alloc, T>) -> bool { + PartialEq::eq(&**self, &**other) + } + + fn ne(&self, other: &Box<'alloc, T>) -> bool { + PartialEq::ne(&**self, &**other) + } +} + +pub fn alloc<'alloc, T>(allocator: &'alloc Bump, value: T) -> Box<'alloc, T> { + Box(allocator.alloc(value)) +} + +pub fn alloc_with<'alloc, F, T>(allocator: &'alloc Bump, gen: F) -> Box<'alloc, T> +where + F: FnOnce() -> T, +{ + Box(allocator.alloc_with(gen)) +} + +pub fn alloc_str<'alloc>(allocator: &'alloc Bump, value: &str) -> &'alloc str { + String::from_str_in(value, allocator).into_bump_str() +} + +pub fn map_vec<'alloc, A, B>( + source: &mut Vec<A>, + mut map_fn: impl FnMut(&mut A) -> B, + allocator: &'alloc Bump, +) -> Vec<'alloc, B> { + let mut out = Vec::with_capacity_in(source.len(), allocator); + for item in source { + out.push(map_fn(item)); + } + out +} diff --git a/third_party/rust/jsparagus-ast/src/associated_data.rs b/third_party/rust/jsparagus-ast/src/associated_data.rs new file mode 100644 index 0000000000..bdde80c0fd --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/associated_data.rs @@ -0,0 +1,143 @@ +use crate::source_location_accessor::SourceLocationAccessor; +use crate::type_id::{NodeTypeId, NodeTypeIdAccessor}; +use crate::SourceLocation; +use std::collections::HashMap; + +#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)] +struct Key { + type_id: NodeTypeId, + loc: SourceLocation, +} + +impl Key { + fn new<NodeT>(node: &NodeT) -> Self + where + NodeT: SourceLocationAccessor + NodeTypeIdAccessor, + { + Self { + type_id: node.get_type_id(), + loc: node.get_loc(), + } + } +} + +impl NodeTypeIdAccessor for Key { + fn get_type_id(&self) -> NodeTypeId { + self.type_id + } +} + +impl SourceLocationAccessor for Key { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +#[derive(Debug)] +struct Item<ValueT> { + #[allow(dead_code)] + key: Key, + value: ValueT, +} + +impl<ValueT> Item<ValueT> { + fn new(key: Key, value: ValueT) -> Self { + Self { key, value } + } +} + +type ItemIndex = usize; + +#[derive(Debug)] +pub struct AssociatedDataItemIndex { + index: ItemIndex, +} +impl AssociatedDataItemIndex { + fn new(index: ItemIndex) -> Self { + Self { index } + } +} + +// A map from AST node to `ValueT`, to associate extra data to AST node. +#[derive(Debug)] +pub struct AssociatedData<ValueT> { + items: Vec<Item<ValueT>>, + map: HashMap<Key, ItemIndex>, +} + +impl<ValueT> AssociatedData<ValueT> { + pub fn new() -> Self { + Self { + items: Vec::new(), + map: HashMap::new(), + } + } + + // Insert an item for `node`. + // Returns the index of the inserted item. + pub fn insert<NodeT>(&mut self, node: &NodeT, value: ValueT) -> AssociatedDataItemIndex + where + NodeT: SourceLocationAccessor + NodeTypeIdAccessor, + { + let index = self.items.len(); + let key = Key::new(node); + self.items.push(Item::new(key.clone(), value)); + self.map.insert(key, index); + + AssociatedDataItemIndex::new(index) + } + + // Get the immutable reference of the item for the index. + // The index is the return value of `insert` or `to_index`. + pub fn get_by_index(&self, index: AssociatedDataItemIndex) -> &ValueT { + // NOTE: This can panic if `index` is created by another instance of + // `AssociatedData`. + &self.items[index.index].value + } + + // Get the mutable reference of the item for the index. + // The index is the return value of `insert` or `to_index`. + pub fn get_mut_by_index(&mut self, index: AssociatedDataItemIndex) -> &mut ValueT { + // NOTE: This can panic if `index` is created by another instance of + // `AssociatedData`. + &mut self.items[index.index].value + } + + // Get the immutable reference of the item for `node`. + // `None` if there's no item inserted for `node`. + pub fn get<NodeT>(&self, node: &NodeT) -> Option<&ValueT> + where + NodeT: SourceLocationAccessor + NodeTypeIdAccessor, + { + self.to_index(node) + .and_then(|index| Some(self.get_by_index(index))) + } + + // Get the mutable reference of the item for `node`. + // `None` if there's no item inserted for `node`. + pub fn get_mut<NodeT>(&mut self, node: &NodeT) -> Option<&mut ValueT> + where + NodeT: SourceLocationAccessor + NodeTypeIdAccessor, + { + self.to_index(node) + .and_then(move |index| Some(self.get_mut_by_index(index))) + } + + // Returns the index for the item for `node`. + // `None` if there's no item inserted for `node`. + pub fn to_index<NodeT>(&self, node: &NodeT) -> Option<AssociatedDataItemIndex> + where + NodeT: SourceLocationAccessor + NodeTypeIdAccessor, + { + let key = Key::new(node); + match self.map.get(&key) { + Some(index) => Some(AssociatedDataItemIndex::new(*index)), + None => None, + } + } +} diff --git a/third_party/rust/jsparagus-ast/src/dump_generated.rs b/third_party/rust/jsparagus-ast/src/dump_generated.rs new file mode 100644 index 0000000000..dfbd7c3dc8 --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/dump_generated.rs @@ -0,0 +1,2269 @@ +// WARNING: This file is auto-generated by crates/ast/generate_ast.py. + +#![allow(unused_variables)] + +use crate::arena; +use crate::source_atom_set::{SourceAtomSet, SourceAtomSetIndex}; +use crate::source_slice_list::{SourceSliceList, SourceSliceIndex}; +use crate::types::*; +use std::ops::Deref; +use std::io; + +fn newline<W>(out: &mut W, depth: usize) +where + W: io::Write, +{ + writeln!(out, "").expect("failed to dump"); + for i in 0..depth { + write!(out, " ").expect("failed to dump"); + } +} + +pub trait ASTDump { + fn dump_with_atoms<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList + ) + where + W: io::Write, + { + self.dump_with_atoms_at(out, atoms, slices, 0); + writeln!(out, "").expect("failed to dump"); + } + + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where W: io::Write; +} +impl<'alloc> ASTDump for Argument<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + Argument::SpreadElement(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Argument::Expression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for Arguments<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Arguments").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "args=").expect("failed to dump"); + self.args.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Identifier { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Identifier").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "value=").expect("failed to dump"); + self.value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for IdentifierName { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(IdentifierName").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "value=").expect("failed to dump"); + self.value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for PrivateIdentifier { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(PrivateIdentifier").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "value=").expect("failed to dump"); + self.value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Label { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Label").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "value=").expect("failed to dump"); + self.value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for VariableDeclarationKind { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + VariableDeclarationKind::Var { .. } => { + write!(out, "Var").expect("failed to dump"); + } + VariableDeclarationKind::Let { .. } => { + write!(out, "Let").expect("failed to dump"); + } + VariableDeclarationKind::Const { .. } => { + write!(out, "Const").expect("failed to dump"); + } + } + } +} + +impl<'alloc> ASTDump for CompoundAssignmentOperator { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + CompoundAssignmentOperator::LogicalOr { .. } => { + write!(out, "LogicalOr").expect("failed to dump"); + } + CompoundAssignmentOperator::LogicalAnd { .. } => { + write!(out, "LogicalAnd").expect("failed to dump"); + } + CompoundAssignmentOperator::Coalesce { .. } => { + write!(out, "Coalesce").expect("failed to dump"); + } + CompoundAssignmentOperator::Add { .. } => { + write!(out, "Add").expect("failed to dump"); + } + CompoundAssignmentOperator::Sub { .. } => { + write!(out, "Sub").expect("failed to dump"); + } + CompoundAssignmentOperator::Mul { .. } => { + write!(out, "Mul").expect("failed to dump"); + } + CompoundAssignmentOperator::Div { .. } => { + write!(out, "Div").expect("failed to dump"); + } + CompoundAssignmentOperator::Mod { .. } => { + write!(out, "Mod").expect("failed to dump"); + } + CompoundAssignmentOperator::Pow { .. } => { + write!(out, "Pow").expect("failed to dump"); + } + CompoundAssignmentOperator::LeftShift { .. } => { + write!(out, "LeftShift").expect("failed to dump"); + } + CompoundAssignmentOperator::RightShift { .. } => { + write!(out, "RightShift").expect("failed to dump"); + } + CompoundAssignmentOperator::RightShiftExt { .. } => { + write!(out, "RightShiftExt").expect("failed to dump"); + } + CompoundAssignmentOperator::Or { .. } => { + write!(out, "Or").expect("failed to dump"); + } + CompoundAssignmentOperator::Xor { .. } => { + write!(out, "Xor").expect("failed to dump"); + } + CompoundAssignmentOperator::And { .. } => { + write!(out, "And").expect("failed to dump"); + } + } + } +} + +impl<'alloc> ASTDump for BinaryOperator { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + BinaryOperator::Equals { .. } => { + write!(out, "Equals").expect("failed to dump"); + } + BinaryOperator::NotEquals { .. } => { + write!(out, "NotEquals").expect("failed to dump"); + } + BinaryOperator::StrictEquals { .. } => { + write!(out, "StrictEquals").expect("failed to dump"); + } + BinaryOperator::StrictNotEquals { .. } => { + write!(out, "StrictNotEquals").expect("failed to dump"); + } + BinaryOperator::LessThan { .. } => { + write!(out, "LessThan").expect("failed to dump"); + } + BinaryOperator::LessThanOrEqual { .. } => { + write!(out, "LessThanOrEqual").expect("failed to dump"); + } + BinaryOperator::GreaterThan { .. } => { + write!(out, "GreaterThan").expect("failed to dump"); + } + BinaryOperator::GreaterThanOrEqual { .. } => { + write!(out, "GreaterThanOrEqual").expect("failed to dump"); + } + BinaryOperator::In { .. } => { + write!(out, "In").expect("failed to dump"); + } + BinaryOperator::Instanceof { .. } => { + write!(out, "Instanceof").expect("failed to dump"); + } + BinaryOperator::LeftShift { .. } => { + write!(out, "LeftShift").expect("failed to dump"); + } + BinaryOperator::RightShift { .. } => { + write!(out, "RightShift").expect("failed to dump"); + } + BinaryOperator::RightShiftExt { .. } => { + write!(out, "RightShiftExt").expect("failed to dump"); + } + BinaryOperator::Add { .. } => { + write!(out, "Add").expect("failed to dump"); + } + BinaryOperator::Sub { .. } => { + write!(out, "Sub").expect("failed to dump"); + } + BinaryOperator::Mul { .. } => { + write!(out, "Mul").expect("failed to dump"); + } + BinaryOperator::Div { .. } => { + write!(out, "Div").expect("failed to dump"); + } + BinaryOperator::Mod { .. } => { + write!(out, "Mod").expect("failed to dump"); + } + BinaryOperator::Pow { .. } => { + write!(out, "Pow").expect("failed to dump"); + } + BinaryOperator::Comma { .. } => { + write!(out, "Comma").expect("failed to dump"); + } + BinaryOperator::Coalesce { .. } => { + write!(out, "Coalesce").expect("failed to dump"); + } + BinaryOperator::LogicalOr { .. } => { + write!(out, "LogicalOr").expect("failed to dump"); + } + BinaryOperator::LogicalAnd { .. } => { + write!(out, "LogicalAnd").expect("failed to dump"); + } + BinaryOperator::BitwiseOr { .. } => { + write!(out, "BitwiseOr").expect("failed to dump"); + } + BinaryOperator::BitwiseXor { .. } => { + write!(out, "BitwiseXor").expect("failed to dump"); + } + BinaryOperator::BitwiseAnd { .. } => { + write!(out, "BitwiseAnd").expect("failed to dump"); + } + } + } +} + +impl<'alloc> ASTDump for UnaryOperator { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + UnaryOperator::Plus { .. } => { + write!(out, "Plus").expect("failed to dump"); + } + UnaryOperator::Minus { .. } => { + write!(out, "Minus").expect("failed to dump"); + } + UnaryOperator::LogicalNot { .. } => { + write!(out, "LogicalNot").expect("failed to dump"); + } + UnaryOperator::BitwiseNot { .. } => { + write!(out, "BitwiseNot").expect("failed to dump"); + } + UnaryOperator::Typeof { .. } => { + write!(out, "Typeof").expect("failed to dump"); + } + UnaryOperator::Void { .. } => { + write!(out, "Void").expect("failed to dump"); + } + UnaryOperator::Delete { .. } => { + write!(out, "Delete").expect("failed to dump"); + } + } + } +} + +impl<'alloc> ASTDump for UpdateOperator { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + UpdateOperator::Increment { .. } => { + write!(out, "Increment").expect("failed to dump"); + } + UpdateOperator::Decrement { .. } => { + write!(out, "Decrement").expect("failed to dump"); + } + } + } +} + +impl<'alloc> ASTDump for Function<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Function").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "is_async=").expect("failed to dump"); + self.is_async.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "is_generator=").expect("failed to dump"); + self.is_generator.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "params=").expect("failed to dump"); + self.params.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + self.body.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Program<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + Program::Module(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Program::Script(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for IfStatement<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(IfStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "test=").expect("failed to dump"); + self.test.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "consequent=").expect("failed to dump"); + self.consequent.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "alternate=").expect("failed to dump"); + self.alternate.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Statement<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + Statement::BlockStatement { block, .. } => { + write!(out, "(BlockStatement").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "block=").expect("failed to dump"); + block.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::BreakStatement { label, .. } => { + write!(out, "(BreakStatement").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "label=").expect("failed to dump"); + label.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::ContinueStatement { label, .. } => { + write!(out, "(ContinueStatement").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "label=").expect("failed to dump"); + label.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::DebuggerStatement { .. } => { + write!(out, "DebuggerStatement").expect("failed to dump"); + } + Statement::DoWhileStatement { block, test, .. } => { + write!(out, "(DoWhileStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "block=").expect("failed to dump"); + block.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "test=").expect("failed to dump"); + test.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::EmptyStatement { .. } => { + write!(out, "EmptyStatement").expect("failed to dump"); + } + Statement::ExpressionStatement(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Statement::ForInStatement { left, right, block, .. } => { + write!(out, "(ForInStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "left=").expect("failed to dump"); + left.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "right=").expect("failed to dump"); + right.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "block=").expect("failed to dump"); + block.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::ForOfStatement { left, right, block, .. } => { + write!(out, "(ForOfStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "left=").expect("failed to dump"); + left.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "right=").expect("failed to dump"); + right.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "block=").expect("failed to dump"); + block.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::ForStatement { init, test, update, block, .. } => { + write!(out, "(ForStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "init=").expect("failed to dump"); + init.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "test=").expect("failed to dump"); + test.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "update=").expect("failed to dump"); + update.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "block=").expect("failed to dump"); + block.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::IfStatement(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Statement::LabelledStatement { label, body, .. } => { + write!(out, "(LabelledStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "label=").expect("failed to dump"); + label.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + body.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::ReturnStatement { expression, .. } => { + write!(out, "(ReturnStatement").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "expression=").expect("failed to dump"); + expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::SwitchStatement { discriminant, cases, .. } => { + write!(out, "(SwitchStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "discriminant=").expect("failed to dump"); + discriminant.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "cases=").expect("failed to dump"); + cases.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::SwitchStatementWithDefault { discriminant, pre_default_cases, default_case, post_default_cases, .. } => { + write!(out, "(SwitchStatementWithDefault").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "discriminant=").expect("failed to dump"); + discriminant.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "pre_default_cases=").expect("failed to dump"); + pre_default_cases.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "default_case=").expect("failed to dump"); + default_case.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "post_default_cases=").expect("failed to dump"); + post_default_cases.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::ThrowStatement { expression, .. } => { + write!(out, "(ThrowStatement").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "expression=").expect("failed to dump"); + expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::TryCatchStatement { body, catch_clause, .. } => { + write!(out, "(TryCatchStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + body.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "catch_clause=").expect("failed to dump"); + catch_clause.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::TryFinallyStatement { body, catch_clause, finalizer, .. } => { + write!(out, "(TryFinallyStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + body.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "catch_clause=").expect("failed to dump"); + catch_clause.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "finalizer=").expect("failed to dump"); + finalizer.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::WhileStatement { test, block, .. } => { + write!(out, "(WhileStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "test=").expect("failed to dump"); + test.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "block=").expect("failed to dump"); + block.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::WithStatement { object, body, .. } => { + write!(out, "(WithStatement").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "object=").expect("failed to dump"); + object.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + body.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Statement::VariableDeclarationStatement(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Statement::FunctionDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Statement::ClassDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for Expression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + Expression::MemberExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::ClassExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::LiteralBooleanExpression { value, .. } => { + write!(out, "(LiteralBooleanExpression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "value=").expect("failed to dump"); + value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::LiteralInfinityExpression { .. } => { + write!(out, "LiteralInfinityExpression").expect("failed to dump"); + } + Expression::LiteralNullExpression { .. } => { + write!(out, "LiteralNullExpression").expect("failed to dump"); + } + Expression::LiteralNumericExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::LiteralRegExpExpression { pattern, global, ignore_case, multi_line, dot_all, sticky, unicode, .. } => { + write!(out, "(LiteralRegExpExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "pattern=").expect("failed to dump"); + pattern.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "global=").expect("failed to dump"); + global.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "ignore_case=").expect("failed to dump"); + ignore_case.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "multi_line=").expect("failed to dump"); + multi_line.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "dot_all=").expect("failed to dump"); + dot_all.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "sticky=").expect("failed to dump"); + sticky.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "unicode=").expect("failed to dump"); + unicode.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::LiteralStringExpression { value, .. } => { + write!(out, "(LiteralStringExpression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "value=").expect("failed to dump"); + value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::ArrayExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::ArrowExpression { is_async, params, body, .. } => { + write!(out, "(ArrowExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "is_async=").expect("failed to dump"); + is_async.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "params=").expect("failed to dump"); + params.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + body.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::AssignmentExpression { binding, expression, .. } => { + write!(out, "(AssignmentExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "expression=").expect("failed to dump"); + expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::BinaryExpression { operator, left, right, .. } => { + write!(out, "(BinaryExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "operator=").expect("failed to dump"); + operator.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "left=").expect("failed to dump"); + left.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "right=").expect("failed to dump"); + right.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::CallExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::CompoundAssignmentExpression { operator, binding, expression, .. } => { + write!(out, "(CompoundAssignmentExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "operator=").expect("failed to dump"); + operator.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "expression=").expect("failed to dump"); + expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::ConditionalExpression { test, consequent, alternate, .. } => { + write!(out, "(ConditionalExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "test=").expect("failed to dump"); + test.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "consequent=").expect("failed to dump"); + consequent.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "alternate=").expect("failed to dump"); + alternate.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::FunctionExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::IdentifierExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::NewExpression { callee, arguments, .. } => { + write!(out, "(NewExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "callee=").expect("failed to dump"); + callee.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "arguments=").expect("failed to dump"); + arguments.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::NewTargetExpression { .. } => { + write!(out, "NewTargetExpression").expect("failed to dump"); + } + Expression::ObjectExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::OptionalExpression { object, tail, .. } => { + write!(out, "(OptionalExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "object=").expect("failed to dump"); + object.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "tail=").expect("failed to dump"); + tail.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::OptionalChain(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::UnaryExpression { operator, operand, .. } => { + write!(out, "(UnaryExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "operator=").expect("failed to dump"); + operator.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "operand=").expect("failed to dump"); + operand.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::TemplateExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Expression::ThisExpression { .. } => { + write!(out, "ThisExpression").expect("failed to dump"); + } + Expression::UpdateExpression { is_prefix, operator, operand, .. } => { + write!(out, "(UpdateExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "is_prefix=").expect("failed to dump"); + is_prefix.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "operator=").expect("failed to dump"); + operator.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "operand=").expect("failed to dump"); + operand.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::YieldExpression { expression, .. } => { + write!(out, "(YieldExpression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "expression=").expect("failed to dump"); + expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::YieldGeneratorExpression { expression, .. } => { + write!(out, "(YieldGeneratorExpression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "expression=").expect("failed to dump"); + expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::AwaitExpression { expression, .. } => { + write!(out, "(AwaitExpression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "expression=").expect("failed to dump"); + expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + Expression::ImportCallExpression { argument, .. } => { + write!(out, "(ImportCallExpression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "argument=").expect("failed to dump"); + argument.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + } + } +} + +impl<'alloc> ASTDump for MemberExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + MemberExpression::ComputedMemberExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + MemberExpression::StaticMemberExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + MemberExpression::PrivateFieldExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for OptionalChain<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + OptionalChain::ComputedMemberExpressionTail { expression, .. } => { + write!(out, "(ComputedMemberExpressionTail").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "expression=").expect("failed to dump"); + expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + OptionalChain::StaticMemberExpressionTail { property, .. } => { + write!(out, "(StaticMemberExpressionTail").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "property=").expect("failed to dump"); + property.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + OptionalChain::PrivateFieldExpressionTail { field, .. } => { + write!(out, "(PrivateFieldExpressionTail").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "field=").expect("failed to dump"); + field.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + OptionalChain::CallExpressionTail { arguments, .. } => { + write!(out, "(CallExpressionTail").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "arguments=").expect("failed to dump"); + arguments.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + OptionalChain::ComputedMemberExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + OptionalChain::StaticMemberExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + OptionalChain::PrivateFieldExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + OptionalChain::CallExpression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for PropertyName<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + PropertyName::ComputedPropertyName(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + PropertyName::StaticPropertyName(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + PropertyName::StaticNumericPropertyName(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for CallExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(CallExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "callee=").expect("failed to dump"); + self.callee.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "arguments=").expect("failed to dump"); + self.arguments.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ClassElementName<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ClassElementName::ComputedPropertyName(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ClassElementName::StaticPropertyName(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ClassElementName::StaticNumericPropertyName(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ClassElementName::PrivateFieldName(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for ObjectProperty<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ObjectProperty::NamedObjectProperty(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ObjectProperty::ShorthandProperty(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ObjectProperty::SpreadProperty(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for NamedObjectProperty<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + NamedObjectProperty::MethodDefinition(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + NamedObjectProperty::DataProperty(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for MethodDefinition<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + MethodDefinition::Method(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + MethodDefinition::Getter(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + MethodDefinition::Setter(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for ImportDeclaration<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ImportDeclaration::Import(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ImportDeclaration::ImportNamespace(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for ExportDeclaration<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ExportDeclaration::ExportAllFrom(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ExportDeclaration::ExportFrom(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ExportDeclaration::ExportLocals(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ExportDeclaration::Export(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ExportDeclaration::ExportDefault(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for VariableReference { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + VariableReference::BindingIdentifier(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + VariableReference::AssignmentTargetIdentifier(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for BindingPattern<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + BindingPattern::ObjectBinding(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + BindingPattern::ArrayBinding(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for Binding<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + Binding::BindingPattern(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Binding::BindingIdentifier(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for SimpleAssignmentTarget<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + SimpleAssignmentTarget::AssignmentTargetIdentifier(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + SimpleAssignmentTarget::MemberAssignmentTarget(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for AssignmentTargetPattern<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + AssignmentTargetPattern::ArrayAssignmentTarget(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + AssignmentTargetPattern::ObjectAssignmentTarget(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for AssignmentTarget<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + AssignmentTarget::AssignmentTargetPattern(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + AssignmentTarget::SimpleAssignmentTarget(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for Parameter<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + Parameter::Binding(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Parameter::BindingWithDefault(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for BindingWithDefault<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(BindingWithDefault").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + self.binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "init=").expect("failed to dump"); + self.init.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for BindingIdentifier { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(BindingIdentifier").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for AssignmentTargetIdentifier { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(AssignmentTargetIdentifier").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ExpressionOrSuper<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ExpressionOrSuper::Expression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ExpressionOrSuper::Super { .. } => { + write!(out, "Super").expect("failed to dump"); + } + } + } +} + +impl<'alloc> ASTDump for MemberAssignmentTarget<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + MemberAssignmentTarget::ComputedMemberAssignmentTarget(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + MemberAssignmentTarget::PrivateFieldAssignmentTarget(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + MemberAssignmentTarget::StaticMemberAssignmentTarget(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for ComputedMemberAssignmentTarget<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ComputedMemberAssignmentTarget").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "object=").expect("failed to dump"); + self.object.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "expression=").expect("failed to dump"); + self.expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for PrivateFieldAssignmentTarget<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(PrivateFieldAssignmentTarget").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "object=").expect("failed to dump"); + self.object.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "field=").expect("failed to dump"); + self.field.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for StaticMemberAssignmentTarget<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(StaticMemberAssignmentTarget").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "object=").expect("failed to dump"); + self.object.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "property=").expect("failed to dump"); + self.property.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ArrayBinding<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ArrayBinding").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "elements=").expect("failed to dump"); + self.elements.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "rest=").expect("failed to dump"); + self.rest.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ObjectBinding<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ObjectBinding").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "properties=").expect("failed to dump"); + self.properties.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "rest=").expect("failed to dump"); + self.rest.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for BindingProperty<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + BindingProperty::BindingPropertyIdentifier(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + BindingProperty::BindingPropertyProperty(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for BindingPropertyIdentifier<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(BindingPropertyIdentifier").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + self.binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "init=").expect("failed to dump"); + self.init.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for BindingPropertyProperty<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(BindingPropertyProperty").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + self.binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for AssignmentTargetWithDefault<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(AssignmentTargetWithDefault").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + self.binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "init=").expect("failed to dump"); + self.init.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for AssignmentTargetMaybeDefault<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + AssignmentTargetMaybeDefault::AssignmentTarget(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for ArrayAssignmentTarget<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ArrayAssignmentTarget").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "elements=").expect("failed to dump"); + self.elements.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "rest=").expect("failed to dump"); + self.rest.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ObjectAssignmentTarget<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ObjectAssignmentTarget").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "properties=").expect("failed to dump"); + self.properties.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "rest=").expect("failed to dump"); + self.rest.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for AssignmentTargetProperty<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + AssignmentTargetProperty::AssignmentTargetPropertyProperty(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for AssignmentTargetPropertyIdentifier<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(AssignmentTargetPropertyIdentifier").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + self.binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "init=").expect("failed to dump"); + self.init.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for AssignmentTargetPropertyProperty<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(AssignmentTargetPropertyProperty").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + self.binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ClassExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ClassExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "super_=").expect("failed to dump"); + self.super_.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "elements=").expect("failed to dump"); + self.elements.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ClassDeclaration<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ClassDeclaration").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "super_=").expect("failed to dump"); + self.super_.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "elements=").expect("failed to dump"); + self.elements.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ClassElement<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ClassElement::MethodDefinition { is_static, method, .. } => { + write!(out, "(MethodDefinition").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "is_static=").expect("failed to dump"); + is_static.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "method=").expect("failed to dump"); + method.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + ClassElement::FieldDefinition { name, init, .. } => { + write!(out, "(FieldDefinition").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "init=").expect("failed to dump"); + init.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + } + } +} + +impl<'alloc> ASTDump for ModuleItems<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ModuleItems::ImportDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ModuleItems::ExportDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ModuleItems::Statement(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for Module<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Module").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "directives=").expect("failed to dump"); + self.directives.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "items=").expect("failed to dump"); + self.items.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Import<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Import").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "module_specifier=").expect("failed to dump"); + self.module_specifier.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "default_binding=").expect("failed to dump"); + self.default_binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "named_imports=").expect("failed to dump"); + self.named_imports.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ImportNamespace { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ImportNamespace").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "module_specifier=").expect("failed to dump"); + self.module_specifier.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "default_binding=").expect("failed to dump"); + self.default_binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "namespace_binding=").expect("failed to dump"); + self.namespace_binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ImportSpecifier { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ImportSpecifier").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + self.binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ExportAllFrom { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ExportAllFrom").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "module_specifier=").expect("failed to dump"); + self.module_specifier.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ExportFrom<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ExportFrom").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "named_exports=").expect("failed to dump"); + self.named_exports.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "module_specifier=").expect("failed to dump"); + self.module_specifier.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ExportLocals<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ExportLocals").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "named_exports=").expect("failed to dump"); + self.named_exports.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Export<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + Export::FunctionDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Export::ClassDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + Export::VariableDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for ExportDefault<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ExportDefault::FunctionDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ExportDefault::ClassDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ExportDefault::Expression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for ExportFromSpecifier { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ExportFromSpecifier").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "exported_name=").expect("failed to dump"); + self.exported_name.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ExportLocalSpecifier { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ExportLocalSpecifier").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "exported_name=").expect("failed to dump"); + self.exported_name.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Method<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Method").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "is_async=").expect("failed to dump"); + self.is_async.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "is_generator=").expect("failed to dump"); + self.is_generator.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "params=").expect("failed to dump"); + self.params.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + self.body.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Getter<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Getter").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "property_name=").expect("failed to dump"); + self.property_name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + self.body.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Setter<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Setter").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "property_name=").expect("failed to dump"); + self.property_name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "param=").expect("failed to dump"); + self.param.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + self.body.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for DataProperty<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(DataProperty").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "property_name=").expect("failed to dump"); + self.property_name.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "expression=").expect("failed to dump"); + self.expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ShorthandProperty { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ShorthandProperty").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ComputedPropertyName<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ComputedPropertyName").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "expression=").expect("failed to dump"); + self.expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for StaticPropertyName { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(StaticPropertyName").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "value=").expect("failed to dump"); + self.value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for NumericLiteral { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(NumericLiteral").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "value=").expect("failed to dump"); + self.value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ArrayExpressionElement<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ArrayExpressionElement::SpreadElement(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ArrayExpressionElement::Expression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ArrayExpressionElement::Elision { .. } => { + write!(out, "Elision").expect("failed to dump"); + } + } + } +} + +impl<'alloc> ASTDump for ArrayExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ArrayExpression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "elements=").expect("failed to dump"); + self.elements.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ArrowExpressionBody<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + ArrowExpressionBody::FunctionBody(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + ArrowExpressionBody::Expression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for ComputedMemberExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ComputedMemberExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "object=").expect("failed to dump"); + self.object.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "expression=").expect("failed to dump"); + self.expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for IdentifierExpression { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(IdentifierExpression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "name=").expect("failed to dump"); + self.name.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for ObjectExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(ObjectExpression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "properties=").expect("failed to dump"); + self.properties.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for StaticMemberExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(StaticMemberExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "object=").expect("failed to dump"); + self.object.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "property=").expect("failed to dump"); + self.property.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for PrivateFieldExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(PrivateFieldExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "object=").expect("failed to dump"); + self.object.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "field=").expect("failed to dump"); + self.field.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for TemplateExpressionElement<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + TemplateExpressionElement::Expression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + TemplateExpressionElement::TemplateElement(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for TemplateExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(TemplateExpression").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "tag=").expect("failed to dump"); + self.tag.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "elements=").expect("failed to dump"); + self.elements.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for VariableDeclarationOrAssignmentTarget<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + VariableDeclarationOrAssignmentTarget::VariableDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + VariableDeclarationOrAssignmentTarget::AssignmentTarget(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for VariableDeclarationOrExpression<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + VariableDeclarationOrExpression::VariableDeclaration(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + VariableDeclarationOrExpression::Expression(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc> ASTDump for Block<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Block").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "statements=").expect("failed to dump"); + self.statements.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "declarations=").expect("failed to dump"); + self.declarations.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for CatchClause<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(CatchClause").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + self.binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "body=").expect("failed to dump"); + self.body.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Directive { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Directive").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "raw_value=").expect("failed to dump"); + self.raw_value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for FormalParameters<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(FormalParameters").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "items=").expect("failed to dump"); + self.items.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "rest=").expect("failed to dump"); + self.rest.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for FunctionBody<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(FunctionBody").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "directives=").expect("failed to dump"); + self.directives.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "statements=").expect("failed to dump"); + self.statements.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for Script<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(Script").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "directives=").expect("failed to dump"); + self.directives.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "statements=").expect("failed to dump"); + self.statements.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for SwitchCase<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(SwitchCase").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "test=").expect("failed to dump"); + self.test.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "consequent=").expect("failed to dump"); + self.consequent.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for SwitchDefault<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(SwitchDefault").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "consequent=").expect("failed to dump"); + self.consequent.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for TemplateElement { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(TemplateElement").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "raw_value=").expect("failed to dump"); + self.raw_value.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for VariableDeclaration<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(VariableDeclaration").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "kind=").expect("failed to dump"); + self.kind.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "declarators=").expect("failed to dump"); + self.declarators.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for VariableDeclarator<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + write!(out, "(VariableDeclarator").expect("failed to dump"); + newline(out, depth + 1); + write!(out, "binding=").expect("failed to dump"); + self.binding.dump_with_atoms_at(out, atoms, slices, depth + 1); + newline(out, depth + 1); + write!(out, "init=").expect("failed to dump"); + self.init.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } +} + +impl<'alloc> ASTDump for CoverParenthesized<'alloc> { + fn dump_with_atoms_at<W>(&self, out: &mut W, atoms: &SourceAtomSet, slices: &SourceSliceList, depth: usize) + where W: io::Write + { + match self { + CoverParenthesized::Expression { expression, .. } => { + write!(out, "(Expression").expect("failed to dump"); + write!(out, " ").expect("failed to dump"); + write!(out, "expression=").expect("failed to dump"); + expression.dump_with_atoms_at(out, atoms, slices, depth + 1); + write!(out, ")").expect("failed to dump"); + } + CoverParenthesized::Parameters(ast) => { + ast.dump_with_atoms_at(out, atoms, slices, depth); + } + } + } +} + +impl<'alloc, T> ASTDump for arena::Vec<'alloc, T> +where + T: ASTDump, +{ + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + write!(out, "[").expect("failed to dump"); + if self.len() > 0 { + for item in self { + newline(out, depth + 1); + item.dump_with_atoms_at(out, atoms, slices, depth + 1); + } + newline(out, depth); + } + write!(out, "]").expect("failed to dump"); + } +} + +impl<T> ASTDump for Option<T> +where + T: ASTDump, +{ + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + match self { + Some(v) => { + v.dump_with_atoms_at(out, atoms, slices, depth); + } + None => { + write!(out, "None").expect("failed to dump"); + } + } + } +} + +impl<'alloc, T> ASTDump for arena::Box<'alloc, T> +where + T: ASTDump, +{ + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + self.deref().dump_with_atoms_at(out, atoms, slices, depth); + } +} + +impl ASTDump for bool { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + if *self { + write!(out, "true").expect("failed to dump"); + } else { + write!(out, "false").expect("failed to dump"); + } + } +} + +impl ASTDump for SourceAtomSetIndex { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + write!(out, "{:?}", atoms.get(self.clone())) + .expect("failed to dump"); + } +} + +impl ASTDump for SourceSliceIndex { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + write!(out, "{:?}", slices.get(self.clone())) + .expect("failed to dump"); + } +} + +impl ASTDump for f64 { + fn dump_with_atoms_at<W>( + &self, + out: &mut W, + atoms: &SourceAtomSet, + slices: &SourceSliceList, + depth: usize, + ) + where + W: io::Write, + { + write!(out, "{}", self).expect("failed to dump"); + } +} diff --git a/third_party/rust/jsparagus-ast/src/lib.rs b/third_party/rust/jsparagus-ast/src/lib.rs new file mode 100644 index 0000000000..3250d73508 --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/lib.rs @@ -0,0 +1,30 @@ +//! The Visage AST (abstract syntax tree). + +pub mod arena; +pub mod associated_data; +pub mod source_atom_set; +pub mod source_location; +pub mod source_slice_list; + +mod source_location_accessor_generated; +pub mod source_location_accessor { + pub use crate::source_location_accessor_generated::*; +} +mod types_generated; +pub mod types { + pub use crate::types_generated::*; +} +mod visit_generated; +pub mod visit { + pub use crate::visit_generated::*; +} +mod type_id_generated; +pub mod type_id { + pub use crate::type_id_generated::*; +} +mod dump_generated; +pub mod dump { + pub use crate::dump_generated::*; +} + +pub use source_location::SourceLocation; diff --git a/third_party/rust/jsparagus-ast/src/source_atom_set.rs b/third_party/rust/jsparagus-ast/src/source_atom_set.rs new file mode 100644 index 0000000000..25369c9777 --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/source_atom_set.rs @@ -0,0 +1,221 @@ +use indexmap::set::IndexSet; + +/// Index into SourceAtomSet.atoms. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub struct SourceAtomSetIndex { + index: usize, +} +impl SourceAtomSetIndex { + fn new(index: usize) -> Self { + Self { index } + } +} + +impl From<SourceAtomSetIndex> for usize { + fn from(index: SourceAtomSetIndex) -> usize { + index.index + } +} + +// Call $handler macro with the list of common atoms. +// +// Basic Usage: +// +// ``` +// for_all_common_atoms!(test); +// ``` +// +// is expanded to +// +// ``` +// test!( +// ("arguments", arguments, Arguments), +// ("async", async_, Async), +// ... +// ); +// ``` +// +// Extra Parameters: +// +// ``` +// for_all_common_atoms!(test, foo, bar); +// ``` +// +// is expanded to +// +// ``` +// test!( +// foo, bar, +// ("arguments", arguments, Arguments), +// ("async", async_, Async), +// ... +// ); +// ``` +macro_rules! for_all_common_atoms { + ($handler:ident $(, $($params:tt)*)?) => { + // string representation, method name, enum variant + $handler!( + $($($params)*,)? + ("arguments", arguments, Arguments), + ("as", as_, As), + ("async", async_, Async), + ("await", await_, Await), + ("break", break_, Break), + ("case", case, Case), + ("catch", catch, Catch), + ("class", class, Class), + ("const", const_, Const), + ("continue", continue_, Continue), + ("debugger", debugger, Debugger), + ("default", default, Default), + ("delete", delete, Delete), + ("do", do_, Do), + ("else", else_, Else), + ("enum", enum_, Enum), + ("eval", eval, Eval), + ("export", export, Export), + ("extends", extends, Extends), + ("false", false_, False), + ("finally", finally, Finally), + ("for", for_, For), + ("from", from, From), + ("function", function, Function), + ("get", get, Get), + ("if", if_, If), + ("implements", implements, Implements), + ("import", import, Import), + ("in", in_, In), + ("instanceof", instanceof, Instanceof), + ("interface", interface, Interface), + ("let", let_, Let), + ("new", new_, New), + ("null", null, Null), + ("of", of, Of), + ("package", package, Package), + ("private", private, Private), + ("protected", protected, Protected), + ("public", public, Public), + ("return", return_, Return), + ("set", set, Set), + ("static", static_, Static), + ("super", super_, Super), + ("switch", switch, Switch), + ("target", target, Target), + ("this", this, This), + ("throw", throw, Throw), + ("true", true_, True), + ("try", try_, Try), + ("typeof", typeof_, Typeof), + ("var", var, Var), + ("void", void, Void), + ("while", while_, While), + ("with", with, With), + ("yield", yield_, Yield), + ("use strict", use_strict, UseStrict), + ("__proto__", __proto__, Proto), + ); + } +} + +// Define CommonAtoms enum, with +// +// enum CommonAtoms { +// Arguments = 0, +// Async, +// ... +// } +macro_rules! define_enum { + (($s0:tt, $method0:ident, $variant0:ident), + $(($s:tt, $method:ident, $variant:ident),)*) => { + enum CommonAtoms { + $variant0 = 0, + $($variant,)* + } + }; +} +for_all_common_atoms!(define_enum); + +// Define CommonSourceAtomSetIndices struct. +// +// impl CommonSourceAtomSetIndices { +// pub fn arguments() -> SourceAtomSetIndex { ... } +// pub fn async_() -> SourceAtomSetIndex { ... } +// ... +// } +macro_rules! define_struct { + ($(($s:tt, $method:ident, $variant:ident),)*) => { + #[derive(Debug)] + pub struct CommonSourceAtomSetIndices {} + + impl CommonSourceAtomSetIndices { + $( + pub fn $method() -> SourceAtomSetIndex { + SourceAtomSetIndex::new(CommonAtoms::$variant as usize) + } + )* + } + }; +} +for_all_common_atoms!(define_struct); + +/// Set of atoms, including the following: +/// +/// * atoms referred from bytecode +/// * variable names referred from scope data +/// +/// WARNING: This set itself does *NOT* map to JSScript::atoms(). +#[derive(Debug)] +pub struct SourceAtomSet<'alloc> { + atoms: IndexSet<&'alloc str>, +} + +impl<'alloc> SourceAtomSet<'alloc> { + // Create a set, with all common atoms inserted. + pub fn new() -> Self { + let mut result = Self { + atoms: IndexSet::new(), + }; + result.insert_common_atoms(); + result + } + + // Insert all common atoms. + fn insert_common_atoms(&mut self) { + macro_rules! insert_atom { + ($self: ident, + $(($s:tt, $method:ident, $variant:ident),)*) => { + $( + $self.atoms.insert($s); + )* + }; + } + for_all_common_atoms!(insert_atom, self); + } + + // Create a set, without any common atoms. + // + // This is for moving `SourceAtomSet` out of `Rc<RefCell>`, by replacing + // it with the result of this method. + pub fn new_uninitialized() -> Self { + Self { + // 256 is a number which should cover 75% of scripts without + // reallocation. + atoms: IndexSet::with_capacity(256), + } + } + + pub fn insert(&mut self, s: &'alloc str) -> SourceAtomSetIndex { + let (index, _) = self.atoms.insert_full(s); + SourceAtomSetIndex::new(index) + } + + pub fn get(&self, index: SourceAtomSetIndex) -> &'alloc str { + self.atoms.get_index(usize::from(index)).unwrap() + } +} + +impl<'alloc> From<SourceAtomSet<'alloc>> for Vec<&'alloc str> { + fn from(set: SourceAtomSet<'alloc>) -> Vec<&'alloc str> { + set.atoms.into_iter().collect() + } +} diff --git a/third_party/rust/jsparagus-ast/src/source_location.rs b/third_party/rust/jsparagus-ast/src/source_location.rs new file mode 100644 index 0000000000..2219fa451e --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/source_location.rs @@ -0,0 +1,32 @@ +#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)] +pub struct SourceLocation { + pub start: usize, + pub end: usize, +} + +impl SourceLocation { + pub fn new(start: usize, end: usize) -> Self { + debug_assert!(start <= end); + + Self { start, end } + } + + pub fn from_parts(start: SourceLocation, end: SourceLocation) -> Self { + debug_assert!(start.start <= end.end); + + Self { + start: start.start, + end: end.end, + } + } + + pub fn set_range(&mut self, start: SourceLocation, end: SourceLocation) { + debug_assert!(start.start <= end.end); + self.start = start.start; + self.end = end.end; + } + + pub fn default() -> Self { + Self { start: 0, end: 0 } + } +} diff --git a/third_party/rust/jsparagus-ast/src/source_location_accessor_generated.rs b/third_party/rust/jsparagus-ast/src/source_location_accessor_generated.rs new file mode 100644 index 0000000000..aec1f962a0 --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/source_location_accessor_generated.rs @@ -0,0 +1,2047 @@ +// WARNING: This file is auto-generated by crates/ast/generate_ast.py. + +use crate::SourceLocation; +use crate::arena; +use crate::types::*; +use std::borrow::{Borrow, BorrowMut}; + +pub trait SourceLocationAccessor { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation); + fn get_loc(&self) -> SourceLocation; +} +impl<'alloc> SourceLocationAccessor for Argument<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + Argument::SpreadElement(content) => { content.set_loc(start, end) } + Argument::Expression(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + Argument::SpreadElement(content) => { content.get_loc() } + Argument::Expression(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for Arguments<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ArrayAssignmentTarget<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ArrayBinding<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ArrayExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ArrayExpressionElement<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ArrayExpressionElement::SpreadElement(content) => { content.set_loc(start, end) } + ArrayExpressionElement::Expression(content) => { content.set_loc(start, end) } + ArrayExpressionElement::Elision { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ArrayExpressionElement::SpreadElement(content) => { content.get_loc() } + ArrayExpressionElement::Expression(content) => { content.get_loc() } + ArrayExpressionElement::Elision { loc } => { + *loc + } + } + } +} + +impl<'alloc> SourceLocationAccessor for ArrowExpressionBody<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ArrowExpressionBody::FunctionBody(content) => { content.set_loc(start, end) } + ArrowExpressionBody::Expression(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ArrowExpressionBody::FunctionBody(content) => { content.get_loc() } + ArrowExpressionBody::Expression(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for AssignmentTarget<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + AssignmentTarget::AssignmentTargetPattern(content) => { content.set_loc(start, end) } + AssignmentTarget::SimpleAssignmentTarget(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + AssignmentTarget::AssignmentTargetPattern(content) => { content.get_loc() } + AssignmentTarget::SimpleAssignmentTarget(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for AssignmentTargetIdentifier { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for AssignmentTargetMaybeDefault<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + AssignmentTargetMaybeDefault::AssignmentTarget(content) => { content.set_loc(start, end) } + AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + AssignmentTargetMaybeDefault::AssignmentTarget(content) => { content.get_loc() } + AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for AssignmentTargetPattern<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + AssignmentTargetPattern::ArrayAssignmentTarget(content) => { content.set_loc(start, end) } + AssignmentTargetPattern::ObjectAssignmentTarget(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + AssignmentTargetPattern::ArrayAssignmentTarget(content) => { content.get_loc() } + AssignmentTargetPattern::ObjectAssignmentTarget(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for AssignmentTargetProperty<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(content) => { content.set_loc(start, end) } + AssignmentTargetProperty::AssignmentTargetPropertyProperty(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(content) => { content.get_loc() } + AssignmentTargetProperty::AssignmentTargetPropertyProperty(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for AssignmentTargetPropertyIdentifier<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for AssignmentTargetPropertyProperty<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for AssignmentTargetWithDefault<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for BinaryOperator { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + BinaryOperator::Equals { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::NotEquals { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::StrictEquals { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::StrictNotEquals { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::LessThan { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::LessThanOrEqual { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::GreaterThan { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::GreaterThanOrEqual { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::In { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::Instanceof { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::LeftShift { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::RightShift { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::RightShiftExt { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::Add { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::Sub { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::Mul { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::Div { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::Mod { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::Pow { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::Comma { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::Coalesce { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::LogicalOr { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::LogicalAnd { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::BitwiseOr { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::BitwiseXor { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + BinaryOperator::BitwiseAnd { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + BinaryOperator::Equals { loc } => { + *loc + } + BinaryOperator::NotEquals { loc } => { + *loc + } + BinaryOperator::StrictEquals { loc } => { + *loc + } + BinaryOperator::StrictNotEquals { loc } => { + *loc + } + BinaryOperator::LessThan { loc } => { + *loc + } + BinaryOperator::LessThanOrEqual { loc } => { + *loc + } + BinaryOperator::GreaterThan { loc } => { + *loc + } + BinaryOperator::GreaterThanOrEqual { loc } => { + *loc + } + BinaryOperator::In { loc } => { + *loc + } + BinaryOperator::Instanceof { loc } => { + *loc + } + BinaryOperator::LeftShift { loc } => { + *loc + } + BinaryOperator::RightShift { loc } => { + *loc + } + BinaryOperator::RightShiftExt { loc } => { + *loc + } + BinaryOperator::Add { loc } => { + *loc + } + BinaryOperator::Sub { loc } => { + *loc + } + BinaryOperator::Mul { loc } => { + *loc + } + BinaryOperator::Div { loc } => { + *loc + } + BinaryOperator::Mod { loc } => { + *loc + } + BinaryOperator::Pow { loc } => { + *loc + } + BinaryOperator::Comma { loc } => { + *loc + } + BinaryOperator::Coalesce { loc } => { + *loc + } + BinaryOperator::LogicalOr { loc } => { + *loc + } + BinaryOperator::LogicalAnd { loc } => { + *loc + } + BinaryOperator::BitwiseOr { loc } => { + *loc + } + BinaryOperator::BitwiseXor { loc } => { + *loc + } + BinaryOperator::BitwiseAnd { loc } => { + *loc + } + } + } +} + +impl<'alloc> SourceLocationAccessor for Binding<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + Binding::BindingPattern(content) => { content.set_loc(start, end) } + Binding::BindingIdentifier(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + Binding::BindingPattern(content) => { content.get_loc() } + Binding::BindingIdentifier(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for BindingIdentifier { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for BindingPattern<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + BindingPattern::ObjectBinding(content) => { content.set_loc(start, end) } + BindingPattern::ArrayBinding(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + BindingPattern::ObjectBinding(content) => { content.get_loc() } + BindingPattern::ArrayBinding(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for BindingProperty<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + BindingProperty::BindingPropertyIdentifier(content) => { content.set_loc(start, end) } + BindingProperty::BindingPropertyProperty(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + BindingProperty::BindingPropertyIdentifier(content) => { content.get_loc() } + BindingProperty::BindingPropertyProperty(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for BindingPropertyIdentifier<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for BindingPropertyProperty<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for BindingWithDefault<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Block<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for CallExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for CatchClause<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ClassDeclaration<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ClassElement<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ClassElement::MethodDefinition { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + ClassElement::FieldDefinition { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ClassElement::MethodDefinition { loc, .. } => { + *loc + } + ClassElement::FieldDefinition { loc, .. } => { + *loc + } + } + } +} + +impl<'alloc> SourceLocationAccessor for ClassElementName<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ClassElementName::ComputedPropertyName(content) => { content.set_loc(start, end) } + ClassElementName::StaticPropertyName(content) => { content.set_loc(start, end) } + ClassElementName::StaticNumericPropertyName(content) => { content.set_loc(start, end) } + ClassElementName::PrivateFieldName(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ClassElementName::ComputedPropertyName(content) => { content.get_loc() } + ClassElementName::StaticPropertyName(content) => { content.get_loc() } + ClassElementName::StaticNumericPropertyName(content) => { content.get_loc() } + ClassElementName::PrivateFieldName(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for ClassExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for CompoundAssignmentOperator { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + CompoundAssignmentOperator::LogicalOr { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::LogicalAnd { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::Coalesce { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::Add { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::Sub { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::Mul { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::Div { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::Mod { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::Pow { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::LeftShift { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::RightShift { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::RightShiftExt { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::Or { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::Xor { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + CompoundAssignmentOperator::And { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + CompoundAssignmentOperator::LogicalOr { loc } => { + *loc + } + CompoundAssignmentOperator::LogicalAnd { loc } => { + *loc + } + CompoundAssignmentOperator::Coalesce { loc } => { + *loc + } + CompoundAssignmentOperator::Add { loc } => { + *loc + } + CompoundAssignmentOperator::Sub { loc } => { + *loc + } + CompoundAssignmentOperator::Mul { loc } => { + *loc + } + CompoundAssignmentOperator::Div { loc } => { + *loc + } + CompoundAssignmentOperator::Mod { loc } => { + *loc + } + CompoundAssignmentOperator::Pow { loc } => { + *loc + } + CompoundAssignmentOperator::LeftShift { loc } => { + *loc + } + CompoundAssignmentOperator::RightShift { loc } => { + *loc + } + CompoundAssignmentOperator::RightShiftExt { loc } => { + *loc + } + CompoundAssignmentOperator::Or { loc } => { + *loc + } + CompoundAssignmentOperator::Xor { loc } => { + *loc + } + CompoundAssignmentOperator::And { loc } => { + *loc + } + } + } +} + +impl<'alloc> SourceLocationAccessor for ComputedMemberAssignmentTarget<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ComputedMemberExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ComputedPropertyName<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for CoverParenthesized<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + CoverParenthesized::Expression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + CoverParenthesized::Parameters(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + CoverParenthesized::Expression { loc, .. } => { + *loc + } + CoverParenthesized::Parameters(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for DataProperty<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Directive { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Export<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + Export::FunctionDeclaration(content) => { content.set_loc(start, end) } + Export::ClassDeclaration(content) => { content.set_loc(start, end) } + Export::VariableDeclaration(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + Export::FunctionDeclaration(content) => { content.get_loc() } + Export::ClassDeclaration(content) => { content.get_loc() } + Export::VariableDeclaration(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for ExportAllFrom { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ExportDeclaration<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ExportDeclaration::ExportAllFrom(content) => { content.set_loc(start, end) } + ExportDeclaration::ExportFrom(content) => { content.set_loc(start, end) } + ExportDeclaration::ExportLocals(content) => { content.set_loc(start, end) } + ExportDeclaration::Export(content) => { content.set_loc(start, end) } + ExportDeclaration::ExportDefault(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ExportDeclaration::ExportAllFrom(content) => { content.get_loc() } + ExportDeclaration::ExportFrom(content) => { content.get_loc() } + ExportDeclaration::ExportLocals(content) => { content.get_loc() } + ExportDeclaration::Export(content) => { content.get_loc() } + ExportDeclaration::ExportDefault(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for ExportDefault<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ExportDefault::FunctionDeclaration(content) => { content.set_loc(start, end) } + ExportDefault::ClassDeclaration(content) => { content.set_loc(start, end) } + ExportDefault::Expression(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ExportDefault::FunctionDeclaration(content) => { content.get_loc() } + ExportDefault::ClassDeclaration(content) => { content.get_loc() } + ExportDefault::Expression(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for ExportFrom<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ExportFromSpecifier { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ExportLocalSpecifier { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ExportLocals<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Expression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + Expression::MemberExpression(content) => { content.set_loc(start, end) } + Expression::ClassExpression(content) => { content.set_loc(start, end) } + Expression::LiteralBooleanExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::LiteralInfinityExpression { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::LiteralNullExpression { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::LiteralNumericExpression(content) => { content.set_loc(start, end) } + Expression::LiteralRegExpExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::LiteralStringExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::ArrayExpression(content) => { content.set_loc(start, end) } + Expression::ArrowExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::AssignmentExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::BinaryExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::CallExpression(content) => { content.set_loc(start, end) } + Expression::CompoundAssignmentExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::ConditionalExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::FunctionExpression(content) => { content.set_loc(start, end) } + Expression::IdentifierExpression(content) => { content.set_loc(start, end) } + Expression::NewExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::NewTargetExpression { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::ObjectExpression(content) => { content.set_loc(start, end) } + Expression::OptionalExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::OptionalChain(content) => { content.set_loc(start, end) } + Expression::UnaryExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::TemplateExpression(content) => { content.set_loc(start, end) } + Expression::ThisExpression { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::UpdateExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::YieldExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::YieldGeneratorExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::AwaitExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Expression::ImportCallExpression { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + Expression::MemberExpression(content) => { content.get_loc() } + Expression::ClassExpression(content) => { content.get_loc() } + Expression::LiteralBooleanExpression { loc, .. } => { + *loc + } + Expression::LiteralInfinityExpression { loc } => { + *loc + } + Expression::LiteralNullExpression { loc } => { + *loc + } + Expression::LiteralNumericExpression(content) => { content.get_loc() } + Expression::LiteralRegExpExpression { loc, .. } => { + *loc + } + Expression::LiteralStringExpression { loc, .. } => { + *loc + } + Expression::ArrayExpression(content) => { content.get_loc() } + Expression::ArrowExpression { loc, .. } => { + *loc + } + Expression::AssignmentExpression { loc, .. } => { + *loc + } + Expression::BinaryExpression { loc, .. } => { + *loc + } + Expression::CallExpression(content) => { content.get_loc() } + Expression::CompoundAssignmentExpression { loc, .. } => { + *loc + } + Expression::ConditionalExpression { loc, .. } => { + *loc + } + Expression::FunctionExpression(content) => { content.get_loc() } + Expression::IdentifierExpression(content) => { content.get_loc() } + Expression::NewExpression { loc, .. } => { + *loc + } + Expression::NewTargetExpression { loc } => { + *loc + } + Expression::ObjectExpression(content) => { content.get_loc() } + Expression::OptionalExpression { loc, .. } => { + *loc + } + Expression::OptionalChain(content) => { content.get_loc() } + Expression::UnaryExpression { loc, .. } => { + *loc + } + Expression::TemplateExpression(content) => { content.get_loc() } + Expression::ThisExpression { loc } => { + *loc + } + Expression::UpdateExpression { loc, .. } => { + *loc + } + Expression::YieldExpression { loc, .. } => { + *loc + } + Expression::YieldGeneratorExpression { loc, .. } => { + *loc + } + Expression::AwaitExpression { loc, .. } => { + *loc + } + Expression::ImportCallExpression { loc, .. } => { + *loc + } + } + } +} + +impl<'alloc> SourceLocationAccessor for ExpressionOrSuper<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ExpressionOrSuper::Expression(content) => { content.set_loc(start, end) } + ExpressionOrSuper::Super { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ExpressionOrSuper::Expression(content) => { content.get_loc() } + ExpressionOrSuper::Super { loc } => { + *loc + } + } + } +} + +impl<'alloc> SourceLocationAccessor for FormalParameters<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Function<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for FunctionBody<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Getter<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Identifier { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for IdentifierExpression { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for IdentifierName { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for IfStatement<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Import<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ImportDeclaration<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ImportDeclaration::Import(content) => { content.set_loc(start, end) } + ImportDeclaration::ImportNamespace(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ImportDeclaration::Import(content) => { content.get_loc() } + ImportDeclaration::ImportNamespace(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for ImportNamespace { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ImportSpecifier { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Label { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for MemberAssignmentTarget<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + MemberAssignmentTarget::ComputedMemberAssignmentTarget(content) => { content.set_loc(start, end) } + MemberAssignmentTarget::PrivateFieldAssignmentTarget(content) => { content.set_loc(start, end) } + MemberAssignmentTarget::StaticMemberAssignmentTarget(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + MemberAssignmentTarget::ComputedMemberAssignmentTarget(content) => { content.get_loc() } + MemberAssignmentTarget::PrivateFieldAssignmentTarget(content) => { content.get_loc() } + MemberAssignmentTarget::StaticMemberAssignmentTarget(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for MemberExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + MemberExpression::ComputedMemberExpression(content) => { content.set_loc(start, end) } + MemberExpression::StaticMemberExpression(content) => { content.set_loc(start, end) } + MemberExpression::PrivateFieldExpression(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + MemberExpression::ComputedMemberExpression(content) => { content.get_loc() } + MemberExpression::StaticMemberExpression(content) => { content.get_loc() } + MemberExpression::PrivateFieldExpression(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for Method<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for MethodDefinition<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + MethodDefinition::Method(content) => { content.set_loc(start, end) } + MethodDefinition::Getter(content) => { content.set_loc(start, end) } + MethodDefinition::Setter(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + MethodDefinition::Method(content) => { content.get_loc() } + MethodDefinition::Getter(content) => { content.get_loc() } + MethodDefinition::Setter(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for Module<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ModuleItems<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ModuleItems::ImportDeclaration(content) => { content.set_loc(start, end) } + ModuleItems::ExportDeclaration(content) => { content.set_loc(start, end) } + ModuleItems::Statement(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ModuleItems::ImportDeclaration(content) => { content.get_loc() } + ModuleItems::ExportDeclaration(content) => { content.get_loc() } + ModuleItems::Statement(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for NamedObjectProperty<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + NamedObjectProperty::MethodDefinition(content) => { content.set_loc(start, end) } + NamedObjectProperty::DataProperty(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + NamedObjectProperty::MethodDefinition(content) => { content.get_loc() } + NamedObjectProperty::DataProperty(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for NumericLiteral { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ObjectAssignmentTarget<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ObjectBinding<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ObjectExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ObjectProperty<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + ObjectProperty::NamedObjectProperty(content) => { content.set_loc(start, end) } + ObjectProperty::ShorthandProperty(content) => { content.set_loc(start, end) } + ObjectProperty::SpreadProperty(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + ObjectProperty::NamedObjectProperty(content) => { content.get_loc() } + ObjectProperty::ShorthandProperty(content) => { content.get_loc() } + ObjectProperty::SpreadProperty(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for OptionalChain<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + OptionalChain::ComputedMemberExpressionTail { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + OptionalChain::StaticMemberExpressionTail { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + OptionalChain::PrivateFieldExpressionTail { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + OptionalChain::CallExpressionTail { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + OptionalChain::ComputedMemberExpression(content) => { content.set_loc(start, end) } + OptionalChain::StaticMemberExpression(content) => { content.set_loc(start, end) } + OptionalChain::PrivateFieldExpression(content) => { content.set_loc(start, end) } + OptionalChain::CallExpression(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + OptionalChain::ComputedMemberExpressionTail { loc, .. } => { + *loc + } + OptionalChain::StaticMemberExpressionTail { loc, .. } => { + *loc + } + OptionalChain::PrivateFieldExpressionTail { loc, .. } => { + *loc + } + OptionalChain::CallExpressionTail { loc, .. } => { + *loc + } + OptionalChain::ComputedMemberExpression(content) => { content.get_loc() } + OptionalChain::StaticMemberExpression(content) => { content.get_loc() } + OptionalChain::PrivateFieldExpression(content) => { content.get_loc() } + OptionalChain::CallExpression(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for Parameter<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + Parameter::Binding(content) => { content.set_loc(start, end) } + Parameter::BindingWithDefault(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + Parameter::Binding(content) => { content.get_loc() } + Parameter::BindingWithDefault(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for PrivateFieldAssignmentTarget<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for PrivateFieldExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for PrivateIdentifier { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Program<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + Program::Module(content) => { content.set_loc(start, end) } + Program::Script(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + Program::Module(content) => { content.get_loc() } + Program::Script(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for PropertyName<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + PropertyName::ComputedPropertyName(content) => { content.set_loc(start, end) } + PropertyName::StaticPropertyName(content) => { content.set_loc(start, end) } + PropertyName::StaticNumericPropertyName(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + PropertyName::ComputedPropertyName(content) => { content.get_loc() } + PropertyName::StaticPropertyName(content) => { content.get_loc() } + PropertyName::StaticNumericPropertyName(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for Script<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for Setter<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for ShorthandProperty { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for SimpleAssignmentTarget<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + SimpleAssignmentTarget::AssignmentTargetIdentifier(content) => { content.set_loc(start, end) } + SimpleAssignmentTarget::MemberAssignmentTarget(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + SimpleAssignmentTarget::AssignmentTargetIdentifier(content) => { content.get_loc() } + SimpleAssignmentTarget::MemberAssignmentTarget(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for Statement<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + Statement::BlockStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::BreakStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::ContinueStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::DebuggerStatement { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::DoWhileStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::EmptyStatement { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::ExpressionStatement(content) => { content.set_loc(start, end) } + Statement::ForInStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::ForOfStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::ForStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::IfStatement(content) => { content.set_loc(start, end) } + Statement::LabelledStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::ReturnStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::SwitchStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::SwitchStatementWithDefault { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::ThrowStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::TryCatchStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::TryFinallyStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::WhileStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::WithStatement { mut loc, .. } => { + loc.start = start.start; + loc.end = end.end; + } + Statement::VariableDeclarationStatement(content) => { content.set_loc(start, end) } + Statement::FunctionDeclaration(content) => { content.set_loc(start, end) } + Statement::ClassDeclaration(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + Statement::BlockStatement { loc, .. } => { + *loc + } + Statement::BreakStatement { loc, .. } => { + *loc + } + Statement::ContinueStatement { loc, .. } => { + *loc + } + Statement::DebuggerStatement { loc } => { + *loc + } + Statement::DoWhileStatement { loc, .. } => { + *loc + } + Statement::EmptyStatement { loc } => { + *loc + } + Statement::ExpressionStatement(content) => { content.get_loc() } + Statement::ForInStatement { loc, .. } => { + *loc + } + Statement::ForOfStatement { loc, .. } => { + *loc + } + Statement::ForStatement { loc, .. } => { + *loc + } + Statement::IfStatement(content) => { content.get_loc() } + Statement::LabelledStatement { loc, .. } => { + *loc + } + Statement::ReturnStatement { loc, .. } => { + *loc + } + Statement::SwitchStatement { loc, .. } => { + *loc + } + Statement::SwitchStatementWithDefault { loc, .. } => { + *loc + } + Statement::ThrowStatement { loc, .. } => { + *loc + } + Statement::TryCatchStatement { loc, .. } => { + *loc + } + Statement::TryFinallyStatement { loc, .. } => { + *loc + } + Statement::WhileStatement { loc, .. } => { + *loc + } + Statement::WithStatement { loc, .. } => { + *loc + } + Statement::VariableDeclarationStatement(content) => { content.get_loc() } + Statement::FunctionDeclaration(content) => { content.get_loc() } + Statement::ClassDeclaration(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for StaticMemberAssignmentTarget<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for StaticMemberExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for StaticPropertyName { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for SwitchCase<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for SwitchDefault<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for TemplateElement { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for TemplateExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for TemplateExpressionElement<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + TemplateExpressionElement::Expression(content) => { content.set_loc(start, end) } + TemplateExpressionElement::TemplateElement(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + TemplateExpressionElement::Expression(content) => { content.get_loc() } + TemplateExpressionElement::TemplateElement(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for UnaryOperator { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + UnaryOperator::Plus { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + UnaryOperator::Minus { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + UnaryOperator::LogicalNot { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + UnaryOperator::BitwiseNot { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + UnaryOperator::Typeof { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + UnaryOperator::Void { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + UnaryOperator::Delete { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + UnaryOperator::Plus { loc } => { + *loc + } + UnaryOperator::Minus { loc } => { + *loc + } + UnaryOperator::LogicalNot { loc } => { + *loc + } + UnaryOperator::BitwiseNot { loc } => { + *loc + } + UnaryOperator::Typeof { loc } => { + *loc + } + UnaryOperator::Void { loc } => { + *loc + } + UnaryOperator::Delete { loc } => { + *loc + } + } + } +} + +impl<'alloc> SourceLocationAccessor for UpdateOperator { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + UpdateOperator::Increment { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + UpdateOperator::Decrement { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + UpdateOperator::Increment { loc } => { + *loc + } + UpdateOperator::Decrement { loc } => { + *loc + } + } + } +} + +impl<'alloc> SourceLocationAccessor for VariableDeclaration<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for VariableDeclarationKind { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + VariableDeclarationKind::Var { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + VariableDeclarationKind::Let { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + VariableDeclarationKind::Const { mut loc } => { + loc.start = start.start; + loc.end = end.end; + } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + VariableDeclarationKind::Var { loc } => { + *loc + } + VariableDeclarationKind::Let { loc } => { + *loc + } + VariableDeclarationKind::Const { loc } => { + *loc + } + } + } +} + +impl<'alloc> SourceLocationAccessor for VariableDeclarationOrAssignmentTarget<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + VariableDeclarationOrAssignmentTarget::VariableDeclaration(content) => { content.set_loc(start, end) } + VariableDeclarationOrAssignmentTarget::AssignmentTarget(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + VariableDeclarationOrAssignmentTarget::VariableDeclaration(content) => { content.get_loc() } + VariableDeclarationOrAssignmentTarget::AssignmentTarget(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for VariableDeclarationOrExpression<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + VariableDeclarationOrExpression::VariableDeclaration(content) => { content.set_loc(start, end) } + VariableDeclarationOrExpression::Expression(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + VariableDeclarationOrExpression::VariableDeclaration(content) => { content.get_loc() } + VariableDeclarationOrExpression::Expression(content) => { content.get_loc() } + } + } +} + +impl<'alloc> SourceLocationAccessor for VariableDeclarator<'alloc> { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + self.loc.start = start.start; + self.loc.end = end.end; + } + + fn get_loc(&self) -> SourceLocation { + self.loc + } +} + +impl<'alloc> SourceLocationAccessor for VariableReference { + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + match self { + VariableReference::BindingIdentifier(content) => { content.set_loc(start, end) } + VariableReference::AssignmentTargetIdentifier(content) => { content.set_loc(start, end) } + } + } + + fn get_loc(&self) -> SourceLocation { + match self { + VariableReference::BindingIdentifier(content) => { content.get_loc() } + VariableReference::AssignmentTargetIdentifier(content) => { content.get_loc() } + } + } +} + +impl<'alloc, T> SourceLocationAccessor for arena::Box<'alloc, T> +where + T: SourceLocationAccessor, +{ + fn set_loc(&mut self, start: SourceLocation, end: SourceLocation) { + (self.borrow_mut() as &mut T).set_loc(start, end) + } + + fn get_loc(&self) -> SourceLocation { + (self.borrow() as &T).get_loc() + } +} diff --git a/third_party/rust/jsparagus-ast/src/source_slice_list.rs b/third_party/rust/jsparagus-ast/src/source_slice_list.rs new file mode 100644 index 0000000000..c7005b3601 --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/source_slice_list.rs @@ -0,0 +1,49 @@ +/// Index into SourceSliceList.items. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub struct SourceSliceIndex { + index: usize, +} +impl SourceSliceIndex { + fn new(index: usize) -> Self { + Self { index } + } +} + +impl From<SourceSliceIndex> for usize { + fn from(index: SourceSliceIndex) -> usize { + index.index + } +} + +/// Set of slices inside source, including the following: +/// +/// * RegExp source +/// * BigInt literal +/// +/// Compared to `SourceAtomSet`, this is not atomized. +#[derive(Debug)] +pub struct SourceSliceList<'alloc> { + items: Vec<&'alloc str>, +} + +impl<'alloc> SourceSliceList<'alloc> { + pub fn new() -> Self { + Self { items: Vec::new() } + } + + pub fn push(&mut self, s: &'alloc str) -> SourceSliceIndex { + let index = self.items.len(); + self.items.push(s); + SourceSliceIndex::new(index) + } + + pub fn get(&self, index: SourceSliceIndex) -> &'alloc str { + self.items.get(usize::from(index)).unwrap() + } +} + +impl<'alloc> From<SourceSliceList<'alloc>> for Vec<&'alloc str> { + fn from(set: SourceSliceList<'alloc>) -> Vec<&'alloc str> { + set.items.into_iter().collect() + } +} diff --git a/third_party/rust/jsparagus-ast/src/type_id_generated.rs b/third_party/rust/jsparagus-ast/src/type_id_generated.rs new file mode 100644 index 0000000000..d764194f24 --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/type_id_generated.rs @@ -0,0 +1,712 @@ +// WARNING: This file is auto-generated. + +use crate::types::*; + +#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)] +pub enum NodeTypeId { + Argument, + Arguments, + Identifier, + IdentifierName, + PrivateIdentifier, + Label, + VariableDeclarationKind, + CompoundAssignmentOperator, + BinaryOperator, + UnaryOperator, + UpdateOperator, + Function, + Program, + IfStatement, + Statement, + Expression, + MemberExpression, + OptionalChain, + PropertyName, + CallExpression, + ClassElementName, + ObjectProperty, + NamedObjectProperty, + MethodDefinition, + ImportDeclaration, + ExportDeclaration, + VariableReference, + BindingPattern, + Binding, + SimpleAssignmentTarget, + AssignmentTargetPattern, + AssignmentTarget, + Parameter, + BindingWithDefault, + BindingIdentifier, + AssignmentTargetIdentifier, + ExpressionOrSuper, + MemberAssignmentTarget, + ComputedMemberAssignmentTarget, + PrivateFieldAssignmentTarget, + StaticMemberAssignmentTarget, + ArrayBinding, + ObjectBinding, + BindingProperty, + BindingPropertyIdentifier, + BindingPropertyProperty, + AssignmentTargetWithDefault, + AssignmentTargetMaybeDefault, + ArrayAssignmentTarget, + ObjectAssignmentTarget, + AssignmentTargetProperty, + AssignmentTargetPropertyIdentifier, + AssignmentTargetPropertyProperty, + ClassExpression, + ClassDeclaration, + ClassElement, + ModuleItems, + Module, + Import, + ImportNamespace, + ImportSpecifier, + ExportAllFrom, + ExportFrom, + ExportLocals, + Export, + ExportDefault, + ExportFromSpecifier, + ExportLocalSpecifier, + Method, + Getter, + Setter, + DataProperty, + ShorthandProperty, + ComputedPropertyName, + StaticPropertyName, + NumericLiteral, + ArrayExpressionElement, + ArrayExpression, + ArrowExpressionBody, + ComputedMemberExpression, + IdentifierExpression, + ObjectExpression, + StaticMemberExpression, + PrivateFieldExpression, + TemplateExpressionElement, + TemplateExpression, + VariableDeclarationOrAssignmentTarget, + VariableDeclarationOrExpression, + Block, + CatchClause, + Directive, + FormalParameters, + FunctionBody, + Script, + SwitchCase, + SwitchDefault, + TemplateElement, + VariableDeclaration, + VariableDeclarator, + CoverParenthesized, +} + +pub trait NodeTypeIdAccessor { + fn get_type_id(&self) -> NodeTypeId; +} + +impl<'alloc> NodeTypeIdAccessor for Argument<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Argument + } +} + +impl<'alloc> NodeTypeIdAccessor for Arguments<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Arguments + } +} + +impl<'alloc> NodeTypeIdAccessor for Identifier { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Identifier + } +} + +impl<'alloc> NodeTypeIdAccessor for IdentifierName { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::IdentifierName + } +} + +impl<'alloc> NodeTypeIdAccessor for PrivateIdentifier { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::PrivateIdentifier + } +} + +impl<'alloc> NodeTypeIdAccessor for Label { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Label + } +} + +impl<'alloc> NodeTypeIdAccessor for VariableDeclarationKind { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::VariableDeclarationKind + } +} + +impl<'alloc> NodeTypeIdAccessor for CompoundAssignmentOperator { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::CompoundAssignmentOperator + } +} + +impl<'alloc> NodeTypeIdAccessor for BinaryOperator { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::BinaryOperator + } +} + +impl<'alloc> NodeTypeIdAccessor for UnaryOperator { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::UnaryOperator + } +} + +impl<'alloc> NodeTypeIdAccessor for UpdateOperator { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::UpdateOperator + } +} + +impl<'alloc> NodeTypeIdAccessor for Function<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Function + } +} + +impl<'alloc> NodeTypeIdAccessor for Program<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Program + } +} + +impl<'alloc> NodeTypeIdAccessor for IfStatement<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::IfStatement + } +} + +impl<'alloc> NodeTypeIdAccessor for Statement<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Statement + } +} + +impl<'alloc> NodeTypeIdAccessor for Expression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Expression + } +} + +impl<'alloc> NodeTypeIdAccessor for MemberExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::MemberExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for OptionalChain<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::OptionalChain + } +} + +impl<'alloc> NodeTypeIdAccessor for PropertyName<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::PropertyName + } +} + +impl<'alloc> NodeTypeIdAccessor for CallExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::CallExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for ClassElementName<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ClassElementName + } +} + +impl<'alloc> NodeTypeIdAccessor for ObjectProperty<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ObjectProperty + } +} + +impl<'alloc> NodeTypeIdAccessor for NamedObjectProperty<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::NamedObjectProperty + } +} + +impl<'alloc> NodeTypeIdAccessor for MethodDefinition<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::MethodDefinition + } +} + +impl<'alloc> NodeTypeIdAccessor for ImportDeclaration<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ImportDeclaration + } +} + +impl<'alloc> NodeTypeIdAccessor for ExportDeclaration<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ExportDeclaration + } +} + +impl<'alloc> NodeTypeIdAccessor for VariableReference { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::VariableReference + } +} + +impl<'alloc> NodeTypeIdAccessor for BindingPattern<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::BindingPattern + } +} + +impl<'alloc> NodeTypeIdAccessor for Binding<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Binding + } +} + +impl<'alloc> NodeTypeIdAccessor for SimpleAssignmentTarget<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::SimpleAssignmentTarget + } +} + +impl<'alloc> NodeTypeIdAccessor for AssignmentTargetPattern<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::AssignmentTargetPattern + } +} + +impl<'alloc> NodeTypeIdAccessor for AssignmentTarget<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::AssignmentTarget + } +} + +impl<'alloc> NodeTypeIdAccessor for Parameter<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Parameter + } +} + +impl<'alloc> NodeTypeIdAccessor for BindingWithDefault<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::BindingWithDefault + } +} + +impl<'alloc> NodeTypeIdAccessor for BindingIdentifier { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::BindingIdentifier + } +} + +impl<'alloc> NodeTypeIdAccessor for AssignmentTargetIdentifier { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::AssignmentTargetIdentifier + } +} + +impl<'alloc> NodeTypeIdAccessor for ExpressionOrSuper<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ExpressionOrSuper + } +} + +impl<'alloc> NodeTypeIdAccessor for MemberAssignmentTarget<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::MemberAssignmentTarget + } +} + +impl<'alloc> NodeTypeIdAccessor for ComputedMemberAssignmentTarget<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ComputedMemberAssignmentTarget + } +} + +impl<'alloc> NodeTypeIdAccessor for PrivateFieldAssignmentTarget<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::PrivateFieldAssignmentTarget + } +} + +impl<'alloc> NodeTypeIdAccessor for StaticMemberAssignmentTarget<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::StaticMemberAssignmentTarget + } +} + +impl<'alloc> NodeTypeIdAccessor for ArrayBinding<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ArrayBinding + } +} + +impl<'alloc> NodeTypeIdAccessor for ObjectBinding<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ObjectBinding + } +} + +impl<'alloc> NodeTypeIdAccessor for BindingProperty<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::BindingProperty + } +} + +impl<'alloc> NodeTypeIdAccessor for BindingPropertyIdentifier<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::BindingPropertyIdentifier + } +} + +impl<'alloc> NodeTypeIdAccessor for BindingPropertyProperty<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::BindingPropertyProperty + } +} + +impl<'alloc> NodeTypeIdAccessor for AssignmentTargetWithDefault<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::AssignmentTargetWithDefault + } +} + +impl<'alloc> NodeTypeIdAccessor for AssignmentTargetMaybeDefault<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::AssignmentTargetMaybeDefault + } +} + +impl<'alloc> NodeTypeIdAccessor for ArrayAssignmentTarget<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ArrayAssignmentTarget + } +} + +impl<'alloc> NodeTypeIdAccessor for ObjectAssignmentTarget<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ObjectAssignmentTarget + } +} + +impl<'alloc> NodeTypeIdAccessor for AssignmentTargetProperty<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::AssignmentTargetProperty + } +} + +impl<'alloc> NodeTypeIdAccessor for AssignmentTargetPropertyIdentifier<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::AssignmentTargetPropertyIdentifier + } +} + +impl<'alloc> NodeTypeIdAccessor for AssignmentTargetPropertyProperty<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::AssignmentTargetPropertyProperty + } +} + +impl<'alloc> NodeTypeIdAccessor for ClassExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ClassExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for ClassDeclaration<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ClassDeclaration + } +} + +impl<'alloc> NodeTypeIdAccessor for ClassElement<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ClassElement + } +} + +impl<'alloc> NodeTypeIdAccessor for ModuleItems<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ModuleItems + } +} + +impl<'alloc> NodeTypeIdAccessor for Module<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Module + } +} + +impl<'alloc> NodeTypeIdAccessor for Import<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Import + } +} + +impl<'alloc> NodeTypeIdAccessor for ImportNamespace { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ImportNamespace + } +} + +impl<'alloc> NodeTypeIdAccessor for ImportSpecifier { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ImportSpecifier + } +} + +impl<'alloc> NodeTypeIdAccessor for ExportAllFrom { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ExportAllFrom + } +} + +impl<'alloc> NodeTypeIdAccessor for ExportFrom<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ExportFrom + } +} + +impl<'alloc> NodeTypeIdAccessor for ExportLocals<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ExportLocals + } +} + +impl<'alloc> NodeTypeIdAccessor for Export<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Export + } +} + +impl<'alloc> NodeTypeIdAccessor for ExportDefault<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ExportDefault + } +} + +impl<'alloc> NodeTypeIdAccessor for ExportFromSpecifier { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ExportFromSpecifier + } +} + +impl<'alloc> NodeTypeIdAccessor for ExportLocalSpecifier { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ExportLocalSpecifier + } +} + +impl<'alloc> NodeTypeIdAccessor for Method<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Method + } +} + +impl<'alloc> NodeTypeIdAccessor for Getter<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Getter + } +} + +impl<'alloc> NodeTypeIdAccessor for Setter<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Setter + } +} + +impl<'alloc> NodeTypeIdAccessor for DataProperty<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::DataProperty + } +} + +impl<'alloc> NodeTypeIdAccessor for ShorthandProperty { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ShorthandProperty + } +} + +impl<'alloc> NodeTypeIdAccessor for ComputedPropertyName<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ComputedPropertyName + } +} + +impl<'alloc> NodeTypeIdAccessor for StaticPropertyName { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::StaticPropertyName + } +} + +impl<'alloc> NodeTypeIdAccessor for NumericLiteral { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::NumericLiteral + } +} + +impl<'alloc> NodeTypeIdAccessor for ArrayExpressionElement<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ArrayExpressionElement + } +} + +impl<'alloc> NodeTypeIdAccessor for ArrayExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ArrayExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for ArrowExpressionBody<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ArrowExpressionBody + } +} + +impl<'alloc> NodeTypeIdAccessor for ComputedMemberExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ComputedMemberExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for IdentifierExpression { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::IdentifierExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for ObjectExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::ObjectExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for StaticMemberExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::StaticMemberExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for PrivateFieldExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::PrivateFieldExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for TemplateExpressionElement<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::TemplateExpressionElement + } +} + +impl<'alloc> NodeTypeIdAccessor for TemplateExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::TemplateExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for VariableDeclarationOrAssignmentTarget<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::VariableDeclarationOrAssignmentTarget + } +} + +impl<'alloc> NodeTypeIdAccessor for VariableDeclarationOrExpression<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::VariableDeclarationOrExpression + } +} + +impl<'alloc> NodeTypeIdAccessor for Block<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Block + } +} + +impl<'alloc> NodeTypeIdAccessor for CatchClause<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::CatchClause + } +} + +impl<'alloc> NodeTypeIdAccessor for Directive { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Directive + } +} + +impl<'alloc> NodeTypeIdAccessor for FormalParameters<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::FormalParameters + } +} + +impl<'alloc> NodeTypeIdAccessor for FunctionBody<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::FunctionBody + } +} + +impl<'alloc> NodeTypeIdAccessor for Script<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::Script + } +} + +impl<'alloc> NodeTypeIdAccessor for SwitchCase<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::SwitchCase + } +} + +impl<'alloc> NodeTypeIdAccessor for SwitchDefault<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::SwitchDefault + } +} + +impl<'alloc> NodeTypeIdAccessor for TemplateElement { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::TemplateElement + } +} + +impl<'alloc> NodeTypeIdAccessor for VariableDeclaration<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::VariableDeclaration + } +} + +impl<'alloc> NodeTypeIdAccessor for VariableDeclarator<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::VariableDeclarator + } +} + +impl<'alloc> NodeTypeIdAccessor for CoverParenthesized<'alloc> { + fn get_type_id(&self) -> NodeTypeId { + NodeTypeId::CoverParenthesized + } +} + diff --git a/third_party/rust/jsparagus-ast/src/types_generated.rs b/third_party/rust/jsparagus-ast/src/types_generated.rs new file mode 100644 index 0000000000..82a9daccfd --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/types_generated.rs @@ -0,0 +1,1055 @@ +// WARNING: This file is auto-generated. + +use crate::source_location::SourceLocation; +use crate::arena; +use crate::source_atom_set::SourceAtomSetIndex; +use crate::source_slice_list::SourceSliceIndex; + +#[derive(Debug, PartialEq)] +pub enum Void { +} + +#[derive(Debug, PartialEq)] +pub enum Argument<'alloc> { + SpreadElement(arena::Box<'alloc, Expression<'alloc>>), + Expression(arena::Box<'alloc, Expression<'alloc>>), +} + +#[derive(Debug, PartialEq)] +pub struct Arguments<'alloc> { + pub args: arena::Vec<'alloc, Argument<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct Identifier { + pub value: SourceAtomSetIndex, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct IdentifierName { + pub value: SourceAtomSetIndex, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct PrivateIdentifier { + pub value: SourceAtomSetIndex, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct Label { + pub value: SourceAtomSetIndex, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum VariableDeclarationKind { + Var { + loc: SourceLocation, + }, + Let { + loc: SourceLocation, + }, + Const { + loc: SourceLocation, + }, +} + +#[derive(Debug, PartialEq)] +pub enum CompoundAssignmentOperator { + LogicalOr { + loc: SourceLocation, + }, + LogicalAnd { + loc: SourceLocation, + }, + Coalesce { + loc: SourceLocation, + }, + Add { + loc: SourceLocation, + }, + Sub { + loc: SourceLocation, + }, + Mul { + loc: SourceLocation, + }, + Div { + loc: SourceLocation, + }, + Mod { + loc: SourceLocation, + }, + Pow { + loc: SourceLocation, + }, + LeftShift { + loc: SourceLocation, + }, + RightShift { + loc: SourceLocation, + }, + RightShiftExt { + loc: SourceLocation, + }, + Or { + loc: SourceLocation, + }, + Xor { + loc: SourceLocation, + }, + And { + loc: SourceLocation, + }, +} + +#[derive(Debug, PartialEq)] +pub enum BinaryOperator { + Equals { + loc: SourceLocation, + }, + NotEquals { + loc: SourceLocation, + }, + StrictEquals { + loc: SourceLocation, + }, + StrictNotEquals { + loc: SourceLocation, + }, + LessThan { + loc: SourceLocation, + }, + LessThanOrEqual { + loc: SourceLocation, + }, + GreaterThan { + loc: SourceLocation, + }, + GreaterThanOrEqual { + loc: SourceLocation, + }, + In { + loc: SourceLocation, + }, + Instanceof { + loc: SourceLocation, + }, + LeftShift { + loc: SourceLocation, + }, + RightShift { + loc: SourceLocation, + }, + RightShiftExt { + loc: SourceLocation, + }, + Add { + loc: SourceLocation, + }, + Sub { + loc: SourceLocation, + }, + Mul { + loc: SourceLocation, + }, + Div { + loc: SourceLocation, + }, + Mod { + loc: SourceLocation, + }, + Pow { + loc: SourceLocation, + }, + Comma { + loc: SourceLocation, + }, + Coalesce { + loc: SourceLocation, + }, + LogicalOr { + loc: SourceLocation, + }, + LogicalAnd { + loc: SourceLocation, + }, + BitwiseOr { + loc: SourceLocation, + }, + BitwiseXor { + loc: SourceLocation, + }, + BitwiseAnd { + loc: SourceLocation, + }, +} + +#[derive(Debug, PartialEq)] +pub enum UnaryOperator { + Plus { + loc: SourceLocation, + }, + Minus { + loc: SourceLocation, + }, + LogicalNot { + loc: SourceLocation, + }, + BitwiseNot { + loc: SourceLocation, + }, + Typeof { + loc: SourceLocation, + }, + Void { + loc: SourceLocation, + }, + Delete { + loc: SourceLocation, + }, +} + +#[derive(Debug, PartialEq)] +pub enum UpdateOperator { + Increment { + loc: SourceLocation, + }, + Decrement { + loc: SourceLocation, + }, +} + +#[derive(Debug, PartialEq)] +pub struct Function<'alloc> { + pub name: Option<BindingIdentifier>, + pub is_async: bool, + pub is_generator: bool, + pub params: FormalParameters<'alloc>, + pub body: FunctionBody<'alloc>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum Program<'alloc> { + Module(Module<'alloc>), + Script(Script<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub struct IfStatement<'alloc> { + pub test: arena::Box<'alloc, Expression<'alloc>>, + pub consequent: arena::Box<'alloc, Statement<'alloc>>, + pub alternate: Option<arena::Box<'alloc, Statement<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum Statement<'alloc> { + BlockStatement { + block: Block<'alloc>, + loc: SourceLocation, + }, + BreakStatement { + label: Option<Label>, + loc: SourceLocation, + }, + ContinueStatement { + label: Option<Label>, + loc: SourceLocation, + }, + DebuggerStatement { + loc: SourceLocation, + }, + DoWhileStatement { + block: arena::Box<'alloc, Statement<'alloc>>, + test: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + EmptyStatement { + loc: SourceLocation, + }, + ExpressionStatement(arena::Box<'alloc, Expression<'alloc>>), + ForInStatement { + left: VariableDeclarationOrAssignmentTarget<'alloc>, + right: arena::Box<'alloc, Expression<'alloc>>, + block: arena::Box<'alloc, Statement<'alloc>>, + loc: SourceLocation, + }, + ForOfStatement { + left: VariableDeclarationOrAssignmentTarget<'alloc>, + right: arena::Box<'alloc, Expression<'alloc>>, + block: arena::Box<'alloc, Statement<'alloc>>, + loc: SourceLocation, + }, + ForStatement { + init: Option<VariableDeclarationOrExpression<'alloc>>, + test: Option<arena::Box<'alloc, Expression<'alloc>>>, + update: Option<arena::Box<'alloc, Expression<'alloc>>>, + block: arena::Box<'alloc, Statement<'alloc>>, + loc: SourceLocation, + }, + IfStatement(IfStatement<'alloc>), + LabelledStatement { + label: Label, + body: arena::Box<'alloc, Statement<'alloc>>, + loc: SourceLocation, + }, + ReturnStatement { + expression: Option<arena::Box<'alloc, Expression<'alloc>>>, + loc: SourceLocation, + }, + SwitchStatement { + discriminant: arena::Box<'alloc, Expression<'alloc>>, + cases: arena::Vec<'alloc, SwitchCase<'alloc>>, + loc: SourceLocation, + }, + SwitchStatementWithDefault { + discriminant: arena::Box<'alloc, Expression<'alloc>>, + pre_default_cases: arena::Vec<'alloc, SwitchCase<'alloc>>, + default_case: SwitchDefault<'alloc>, + post_default_cases: arena::Vec<'alloc, SwitchCase<'alloc>>, + loc: SourceLocation, + }, + ThrowStatement { + expression: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + TryCatchStatement { + body: Block<'alloc>, + catch_clause: CatchClause<'alloc>, + loc: SourceLocation, + }, + TryFinallyStatement { + body: Block<'alloc>, + catch_clause: Option<CatchClause<'alloc>>, + finalizer: Block<'alloc>, + loc: SourceLocation, + }, + WhileStatement { + test: arena::Box<'alloc, Expression<'alloc>>, + block: arena::Box<'alloc, Statement<'alloc>>, + loc: SourceLocation, + }, + WithStatement { + object: arena::Box<'alloc, Expression<'alloc>>, + body: arena::Box<'alloc, Statement<'alloc>>, + loc: SourceLocation, + }, + VariableDeclarationStatement(VariableDeclaration<'alloc>), + FunctionDeclaration(Function<'alloc>), + ClassDeclaration(ClassDeclaration<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum Expression<'alloc> { + MemberExpression(MemberExpression<'alloc>), + ClassExpression(ClassExpression<'alloc>), + LiteralBooleanExpression { + value: bool, + loc: SourceLocation, + }, + LiteralInfinityExpression { + loc: SourceLocation, + }, + LiteralNullExpression { + loc: SourceLocation, + }, + LiteralNumericExpression(NumericLiteral), + LiteralRegExpExpression { + pattern: SourceSliceIndex, + global: bool, + ignore_case: bool, + multi_line: bool, + dot_all: bool, + sticky: bool, + unicode: bool, + loc: SourceLocation, + }, + LiteralStringExpression { + value: SourceAtomSetIndex, + loc: SourceLocation, + }, + ArrayExpression(ArrayExpression<'alloc>), + ArrowExpression { + is_async: bool, + params: FormalParameters<'alloc>, + body: ArrowExpressionBody<'alloc>, + loc: SourceLocation, + }, + AssignmentExpression { + binding: AssignmentTarget<'alloc>, + expression: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + BinaryExpression { + operator: BinaryOperator, + left: arena::Box<'alloc, Expression<'alloc>>, + right: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + CallExpression(CallExpression<'alloc>), + CompoundAssignmentExpression { + operator: CompoundAssignmentOperator, + binding: SimpleAssignmentTarget<'alloc>, + expression: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + ConditionalExpression { + test: arena::Box<'alloc, Expression<'alloc>>, + consequent: arena::Box<'alloc, Expression<'alloc>>, + alternate: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + FunctionExpression(Function<'alloc>), + IdentifierExpression(IdentifierExpression), + NewExpression { + callee: arena::Box<'alloc, Expression<'alloc>>, + arguments: Arguments<'alloc>, + loc: SourceLocation, + }, + NewTargetExpression { + loc: SourceLocation, + }, + ObjectExpression(ObjectExpression<'alloc>), + OptionalExpression { + object: ExpressionOrSuper<'alloc>, + tail: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + OptionalChain(OptionalChain<'alloc>), + UnaryExpression { + operator: UnaryOperator, + operand: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + TemplateExpression(TemplateExpression<'alloc>), + ThisExpression { + loc: SourceLocation, + }, + UpdateExpression { + is_prefix: bool, + operator: UpdateOperator, + operand: SimpleAssignmentTarget<'alloc>, + loc: SourceLocation, + }, + YieldExpression { + expression: Option<arena::Box<'alloc, Expression<'alloc>>>, + loc: SourceLocation, + }, + YieldGeneratorExpression { + expression: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + AwaitExpression { + expression: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + ImportCallExpression { + argument: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, +} + +#[derive(Debug, PartialEq)] +pub enum MemberExpression<'alloc> { + ComputedMemberExpression(ComputedMemberExpression<'alloc>), + StaticMemberExpression(StaticMemberExpression<'alloc>), + PrivateFieldExpression(PrivateFieldExpression<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum OptionalChain<'alloc> { + ComputedMemberExpressionTail { + expression: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + StaticMemberExpressionTail { + property: IdentifierName, + loc: SourceLocation, + }, + PrivateFieldExpressionTail { + field: PrivateIdentifier, + loc: SourceLocation, + }, + CallExpressionTail { + arguments: Arguments<'alloc>, + loc: SourceLocation, + }, + ComputedMemberExpression(ComputedMemberExpression<'alloc>), + StaticMemberExpression(StaticMemberExpression<'alloc>), + PrivateFieldExpression(PrivateFieldExpression<'alloc>), + CallExpression(CallExpression<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum PropertyName<'alloc> { + ComputedPropertyName(ComputedPropertyName<'alloc>), + StaticPropertyName(StaticPropertyName), + StaticNumericPropertyName(NumericLiteral), +} + +#[derive(Debug, PartialEq)] +pub struct CallExpression<'alloc> { + pub callee: ExpressionOrSuper<'alloc>, + pub arguments: Arguments<'alloc>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum ClassElementName<'alloc> { + ComputedPropertyName(ComputedPropertyName<'alloc>), + StaticPropertyName(StaticPropertyName), + StaticNumericPropertyName(NumericLiteral), + PrivateFieldName(PrivateIdentifier), +} + +#[derive(Debug, PartialEq)] +pub enum ObjectProperty<'alloc> { + NamedObjectProperty(NamedObjectProperty<'alloc>), + ShorthandProperty(ShorthandProperty), + SpreadProperty(arena::Box<'alloc, Expression<'alloc>>), +} + +#[derive(Debug, PartialEq)] +pub enum NamedObjectProperty<'alloc> { + MethodDefinition(MethodDefinition<'alloc>), + DataProperty(DataProperty<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum MethodDefinition<'alloc> { + Method(Method<'alloc>), + Getter(Getter<'alloc>), + Setter(Setter<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum ImportDeclaration<'alloc> { + Import(Import<'alloc>), + ImportNamespace(ImportNamespace), +} + +#[derive(Debug, PartialEq)] +pub enum ExportDeclaration<'alloc> { + ExportAllFrom(ExportAllFrom), + ExportFrom(ExportFrom<'alloc>), + ExportLocals(ExportLocals<'alloc>), + Export(Export<'alloc>), + ExportDefault(ExportDefault<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum VariableReference { + BindingIdentifier(BindingIdentifier), + AssignmentTargetIdentifier(AssignmentTargetIdentifier), +} + +#[derive(Debug, PartialEq)] +pub enum BindingPattern<'alloc> { + ObjectBinding(ObjectBinding<'alloc>), + ArrayBinding(ArrayBinding<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum Binding<'alloc> { + BindingPattern(BindingPattern<'alloc>), + BindingIdentifier(BindingIdentifier), +} + +#[derive(Debug, PartialEq)] +pub enum SimpleAssignmentTarget<'alloc> { + AssignmentTargetIdentifier(AssignmentTargetIdentifier), + MemberAssignmentTarget(MemberAssignmentTarget<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum AssignmentTargetPattern<'alloc> { + ArrayAssignmentTarget(ArrayAssignmentTarget<'alloc>), + ObjectAssignmentTarget(ObjectAssignmentTarget<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum AssignmentTarget<'alloc> { + AssignmentTargetPattern(AssignmentTargetPattern<'alloc>), + SimpleAssignmentTarget(SimpleAssignmentTarget<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum Parameter<'alloc> { + Binding(Binding<'alloc>), + BindingWithDefault(BindingWithDefault<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub struct BindingWithDefault<'alloc> { + pub binding: Binding<'alloc>, + pub init: arena::Box<'alloc, Expression<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct BindingIdentifier { + pub name: Identifier, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct AssignmentTargetIdentifier { + pub name: Identifier, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum ExpressionOrSuper<'alloc> { + Expression(arena::Box<'alloc, Expression<'alloc>>), + Super { + loc: SourceLocation, + }, +} + +#[derive(Debug, PartialEq)] +pub enum MemberAssignmentTarget<'alloc> { + ComputedMemberAssignmentTarget(ComputedMemberAssignmentTarget<'alloc>), + PrivateFieldAssignmentTarget(PrivateFieldAssignmentTarget<'alloc>), + StaticMemberAssignmentTarget(StaticMemberAssignmentTarget<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub struct ComputedMemberAssignmentTarget<'alloc> { + pub object: ExpressionOrSuper<'alloc>, + pub expression: arena::Box<'alloc, Expression<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct PrivateFieldAssignmentTarget<'alloc> { + pub object: ExpressionOrSuper<'alloc>, + pub field: PrivateIdentifier, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct StaticMemberAssignmentTarget<'alloc> { + pub object: ExpressionOrSuper<'alloc>, + pub property: IdentifierName, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ArrayBinding<'alloc> { + pub elements: arena::Vec<'alloc, Option<Parameter<'alloc>>>, + pub rest: Option<arena::Box<'alloc, Binding<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ObjectBinding<'alloc> { + pub properties: arena::Vec<'alloc, BindingProperty<'alloc>>, + pub rest: Option<arena::Box<'alloc, BindingIdentifier>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum BindingProperty<'alloc> { + BindingPropertyIdentifier(BindingPropertyIdentifier<'alloc>), + BindingPropertyProperty(BindingPropertyProperty<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub struct BindingPropertyIdentifier<'alloc> { + pub binding: BindingIdentifier, + pub init: Option<arena::Box<'alloc, Expression<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct BindingPropertyProperty<'alloc> { + pub name: PropertyName<'alloc>, + pub binding: Parameter<'alloc>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct AssignmentTargetWithDefault<'alloc> { + pub binding: AssignmentTarget<'alloc>, + pub init: arena::Box<'alloc, Expression<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum AssignmentTargetMaybeDefault<'alloc> { + AssignmentTarget(AssignmentTarget<'alloc>), + AssignmentTargetWithDefault(AssignmentTargetWithDefault<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub struct ArrayAssignmentTarget<'alloc> { + pub elements: arena::Vec<'alloc, Option<AssignmentTargetMaybeDefault<'alloc>>>, + pub rest: Option<arena::Box<'alloc, AssignmentTarget<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ObjectAssignmentTarget<'alloc> { + pub properties: arena::Vec<'alloc, AssignmentTargetProperty<'alloc>>, + pub rest: Option<arena::Box<'alloc, AssignmentTarget<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum AssignmentTargetProperty<'alloc> { + AssignmentTargetPropertyIdentifier(AssignmentTargetPropertyIdentifier<'alloc>), + AssignmentTargetPropertyProperty(AssignmentTargetPropertyProperty<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub struct AssignmentTargetPropertyIdentifier<'alloc> { + pub binding: AssignmentTargetIdentifier, + pub init: Option<arena::Box<'alloc, Expression<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct AssignmentTargetPropertyProperty<'alloc> { + pub name: PropertyName<'alloc>, + pub binding: AssignmentTargetMaybeDefault<'alloc>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ClassExpression<'alloc> { + pub name: Option<BindingIdentifier>, + pub super_: Option<arena::Box<'alloc, Expression<'alloc>>>, + pub elements: arena::Vec<'alloc, arena::Box<'alloc, ClassElement<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ClassDeclaration<'alloc> { + pub name: BindingIdentifier, + pub super_: Option<arena::Box<'alloc, Expression<'alloc>>>, + pub elements: arena::Vec<'alloc, arena::Box<'alloc, ClassElement<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum ClassElement<'alloc> { + MethodDefinition { + is_static: bool, + method: MethodDefinition<'alloc>, + loc: SourceLocation, + }, + FieldDefinition { + name: ClassElementName<'alloc>, + init: Option<arena::Box<'alloc, Expression<'alloc>>>, + loc: SourceLocation, + }, +} + +#[derive(Debug, PartialEq)] +pub enum ModuleItems<'alloc> { + ImportDeclaration(ImportDeclaration<'alloc>), + ExportDeclaration(ExportDeclaration<'alloc>), + Statement(arena::Box<'alloc, Statement<'alloc>>), +} + +#[derive(Debug, PartialEq)] +pub struct Module<'alloc> { + pub directives: arena::Vec<'alloc, Directive>, + pub items: arena::Vec<'alloc, ModuleItems<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct Import<'alloc> { + pub module_specifier: SourceAtomSetIndex, + pub default_binding: Option<BindingIdentifier>, + pub named_imports: arena::Vec<'alloc, ImportSpecifier>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ImportNamespace { + pub module_specifier: SourceAtomSetIndex, + pub default_binding: Option<BindingIdentifier>, + pub namespace_binding: BindingIdentifier, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ImportSpecifier { + pub name: Option<IdentifierName>, + pub binding: BindingIdentifier, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ExportAllFrom { + pub module_specifier: SourceAtomSetIndex, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ExportFrom<'alloc> { + pub named_exports: arena::Vec<'alloc, ExportFromSpecifier>, + pub module_specifier: SourceAtomSetIndex, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ExportLocals<'alloc> { + pub named_exports: arena::Vec<'alloc, ExportLocalSpecifier>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum Export<'alloc> { + FunctionDeclaration(Function<'alloc>), + ClassDeclaration(ClassDeclaration<'alloc>), + VariableDeclaration(VariableDeclaration<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum ExportDefault<'alloc> { + FunctionDeclaration(Function<'alloc>), + ClassDeclaration(ClassDeclaration<'alloc>), + Expression(arena::Box<'alloc, Expression<'alloc>>), +} + +#[derive(Debug, PartialEq)] +pub struct ExportFromSpecifier { + pub name: IdentifierName, + pub exported_name: Option<IdentifierName>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ExportLocalSpecifier { + pub name: IdentifierExpression, + pub exported_name: Option<IdentifierName>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct Method<'alloc> { + pub name: ClassElementName<'alloc>, + pub is_async: bool, + pub is_generator: bool, + pub params: FormalParameters<'alloc>, + pub body: FunctionBody<'alloc>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct Getter<'alloc> { + pub property_name: ClassElementName<'alloc>, + pub body: FunctionBody<'alloc>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct Setter<'alloc> { + pub property_name: ClassElementName<'alloc>, + pub param: Parameter<'alloc>, + pub body: FunctionBody<'alloc>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct DataProperty<'alloc> { + pub property_name: PropertyName<'alloc>, + pub expression: arena::Box<'alloc, Expression<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ShorthandProperty { + pub name: IdentifierExpression, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ComputedPropertyName<'alloc> { + pub expression: arena::Box<'alloc, Expression<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct StaticPropertyName { + pub value: SourceAtomSetIndex, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct NumericLiteral { + pub value: f64, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum ArrayExpressionElement<'alloc> { + SpreadElement(arena::Box<'alloc, Expression<'alloc>>), + Expression(arena::Box<'alloc, Expression<'alloc>>), + Elision { + loc: SourceLocation, + }, +} + +#[derive(Debug, PartialEq)] +pub struct ArrayExpression<'alloc> { + pub elements: arena::Vec<'alloc, ArrayExpressionElement<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum ArrowExpressionBody<'alloc> { + FunctionBody(FunctionBody<'alloc>), + Expression(arena::Box<'alloc, Expression<'alloc>>), +} + +#[derive(Debug, PartialEq)] +pub struct ComputedMemberExpression<'alloc> { + pub object: ExpressionOrSuper<'alloc>, + pub expression: arena::Box<'alloc, Expression<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct IdentifierExpression { + pub name: Identifier, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct ObjectExpression<'alloc> { + pub properties: arena::Vec<'alloc, arena::Box<'alloc, ObjectProperty<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct StaticMemberExpression<'alloc> { + pub object: ExpressionOrSuper<'alloc>, + pub property: IdentifierName, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct PrivateFieldExpression<'alloc> { + pub object: ExpressionOrSuper<'alloc>, + pub field: PrivateIdentifier, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum TemplateExpressionElement<'alloc> { + Expression(arena::Box<'alloc, Expression<'alloc>>), + TemplateElement(TemplateElement), +} + +#[derive(Debug, PartialEq)] +pub struct TemplateExpression<'alloc> { + pub tag: Option<arena::Box<'alloc, Expression<'alloc>>>, + pub elements: arena::Vec<'alloc, TemplateExpressionElement<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum VariableDeclarationOrAssignmentTarget<'alloc> { + VariableDeclaration(VariableDeclaration<'alloc>), + AssignmentTarget(AssignmentTarget<'alloc>), +} + +#[derive(Debug, PartialEq)] +pub enum VariableDeclarationOrExpression<'alloc> { + VariableDeclaration(VariableDeclaration<'alloc>), + Expression(arena::Box<'alloc, Expression<'alloc>>), +} + +#[derive(Debug, PartialEq)] +pub struct Block<'alloc> { + pub statements: arena::Vec<'alloc, Statement<'alloc>>, + pub declarations: Option<arena::Vec<'alloc, SourceAtomSetIndex>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct CatchClause<'alloc> { + pub binding: Option<arena::Box<'alloc, Binding<'alloc>>>, + pub body: Block<'alloc>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct Directive { + pub raw_value: SourceAtomSetIndex, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct FormalParameters<'alloc> { + pub items: arena::Vec<'alloc, Parameter<'alloc>>, + pub rest: Option<Binding<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct FunctionBody<'alloc> { + pub directives: arena::Vec<'alloc, Directive>, + pub statements: arena::Vec<'alloc, Statement<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct Script<'alloc> { + pub directives: arena::Vec<'alloc, Directive>, + pub statements: arena::Vec<'alloc, Statement<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct SwitchCase<'alloc> { + pub test: arena::Box<'alloc, Expression<'alloc>>, + pub consequent: arena::Vec<'alloc, Statement<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct SwitchDefault<'alloc> { + pub consequent: arena::Vec<'alloc, Statement<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct TemplateElement { + pub raw_value: SourceAtomSetIndex, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct VariableDeclaration<'alloc> { + pub kind: VariableDeclarationKind, + pub declarators: arena::Vec<'alloc, VariableDeclarator<'alloc>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub struct VariableDeclarator<'alloc> { + pub binding: Binding<'alloc>, + pub init: Option<arena::Box<'alloc, Expression<'alloc>>>, + pub loc: SourceLocation, +} + +#[derive(Debug, PartialEq)] +pub enum CoverParenthesized<'alloc> { + Expression { + expression: arena::Box<'alloc, Expression<'alloc>>, + loc: SourceLocation, + }, + Parameters(arena::Box<'alloc, FormalParameters<'alloc>>), +} + diff --git a/third_party/rust/jsparagus-ast/src/visit_generated.rs b/third_party/rust/jsparagus-ast/src/visit_generated.rs new file mode 100644 index 0000000000..58a914c38e --- /dev/null +++ b/third_party/rust/jsparagus-ast/src/visit_generated.rs @@ -0,0 +1,5423 @@ +// WARNING: This file is auto-generated. + +#![allow(unused_mut)] +#![allow(unused_parens)] +#![allow(unused_variables)] +#![allow(dead_code)] + +use crate::arena; +use crate::source_atom_set::SourceAtomSetIndex; +use crate::source_slice_list::SourceSliceIndex; +use crate::types::*; + +pub trait Pass<'alloc> { + fn visit_argument(&mut self, ast: &'alloc Argument<'alloc>) { + self.enter_argument(ast); + match ast { + Argument::SpreadElement(ast) => { + self.visit_enum_argument_variant_spread_element(ast) + } + Argument::Expression(ast) => { + self.visit_enum_argument_variant_expression(ast) + } + } + self.leave_argument(ast); + } + + fn enter_argument(&mut self, ast: &'alloc Argument<'alloc>) { + } + + fn leave_argument(&mut self, ast: &'alloc Argument<'alloc>) { + } + + fn visit_enum_argument_variant_spread_element( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_argument_variant_spread_element(ast); + self.visit_expression(ast); + self.leave_enum_argument_variant_spread_element(ast); + } + + fn enter_enum_argument_variant_spread_element( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_argument_variant_spread_element( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_argument_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_argument_variant_expression(ast); + self.visit_expression(ast); + self.leave_enum_argument_variant_expression(ast); + } + + fn enter_enum_argument_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_argument_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_arguments(&mut self, ast: &'alloc Arguments<'alloc>) { + self.enter_arguments(ast); + for item in &ast.args { + self.visit_argument(item); + } + self.leave_arguments(ast); + } + + fn enter_arguments(&mut self, ast: &'alloc Arguments<'alloc>) { + } + + fn leave_arguments(&mut self, ast: &'alloc Arguments<'alloc>) { + } + + fn visit_identifier(&mut self, ast: &'alloc Identifier) { + self.enter_identifier(ast); + self.leave_identifier(ast); + } + + fn enter_identifier(&mut self, ast: &'alloc Identifier) { + } + + fn leave_identifier(&mut self, ast: &'alloc Identifier) { + } + + fn visit_identifier_name(&mut self, ast: &'alloc IdentifierName) { + self.enter_identifier_name(ast); + self.leave_identifier_name(ast); + } + + fn enter_identifier_name(&mut self, ast: &'alloc IdentifierName) { + } + + fn leave_identifier_name(&mut self, ast: &'alloc IdentifierName) { + } + + fn visit_private_identifier(&mut self, ast: &'alloc PrivateIdentifier) { + self.enter_private_identifier(ast); + self.leave_private_identifier(ast); + } + + fn enter_private_identifier(&mut self, ast: &'alloc PrivateIdentifier) { + } + + fn leave_private_identifier(&mut self, ast: &'alloc PrivateIdentifier) { + } + + fn visit_label(&mut self, ast: &'alloc Label) { + self.enter_label(ast); + self.leave_label(ast); + } + + fn enter_label(&mut self, ast: &'alloc Label) { + } + + fn leave_label(&mut self, ast: &'alloc Label) { + } + + fn visit_variable_declaration_kind(&mut self, ast: &'alloc VariableDeclarationKind) { + self.enter_variable_declaration_kind(ast); + match ast { + VariableDeclarationKind::Var { .. } => { + self.visit_enum_variable_declaration_kind_variant_var() + } + VariableDeclarationKind::Let { .. } => { + self.visit_enum_variable_declaration_kind_variant_let() + } + VariableDeclarationKind::Const { .. } => { + self.visit_enum_variable_declaration_kind_variant_const() + } + } + self.leave_variable_declaration_kind(ast); + } + + fn enter_variable_declaration_kind(&mut self, ast: &'alloc VariableDeclarationKind) { + } + + fn leave_variable_declaration_kind(&mut self, ast: &'alloc VariableDeclarationKind) { + } + + fn visit_enum_variable_declaration_kind_variant_var(&mut self) { + } + + fn visit_enum_variable_declaration_kind_variant_let(&mut self) { + } + + fn visit_enum_variable_declaration_kind_variant_const(&mut self) { + } + + fn visit_compound_assignment_operator(&mut self, ast: &'alloc CompoundAssignmentOperator) { + self.enter_compound_assignment_operator(ast); + match ast { + CompoundAssignmentOperator::LogicalOr { .. } => { + self.visit_enum_compound_assignment_operator_variant_logical_or() + } + CompoundAssignmentOperator::LogicalAnd { .. } => { + self.visit_enum_compound_assignment_operator_variant_logical_and() + } + CompoundAssignmentOperator::Coalesce { .. } => { + self.visit_enum_compound_assignment_operator_variant_coalesce() + } + CompoundAssignmentOperator::Add { .. } => { + self.visit_enum_compound_assignment_operator_variant_add() + } + CompoundAssignmentOperator::Sub { .. } => { + self.visit_enum_compound_assignment_operator_variant_sub() + } + CompoundAssignmentOperator::Mul { .. } => { + self.visit_enum_compound_assignment_operator_variant_mul() + } + CompoundAssignmentOperator::Div { .. } => { + self.visit_enum_compound_assignment_operator_variant_div() + } + CompoundAssignmentOperator::Mod { .. } => { + self.visit_enum_compound_assignment_operator_variant_mod() + } + CompoundAssignmentOperator::Pow { .. } => { + self.visit_enum_compound_assignment_operator_variant_pow() + } + CompoundAssignmentOperator::LeftShift { .. } => { + self.visit_enum_compound_assignment_operator_variant_left_shift() + } + CompoundAssignmentOperator::RightShift { .. } => { + self.visit_enum_compound_assignment_operator_variant_right_shift() + } + CompoundAssignmentOperator::RightShiftExt { .. } => { + self.visit_enum_compound_assignment_operator_variant_right_shift_ext() + } + CompoundAssignmentOperator::Or { .. } => { + self.visit_enum_compound_assignment_operator_variant_or() + } + CompoundAssignmentOperator::Xor { .. } => { + self.visit_enum_compound_assignment_operator_variant_xor() + } + CompoundAssignmentOperator::And { .. } => { + self.visit_enum_compound_assignment_operator_variant_and() + } + } + self.leave_compound_assignment_operator(ast); + } + + fn enter_compound_assignment_operator(&mut self, ast: &'alloc CompoundAssignmentOperator) { + } + + fn leave_compound_assignment_operator(&mut self, ast: &'alloc CompoundAssignmentOperator) { + } + + fn visit_enum_compound_assignment_operator_variant_logical_or(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_logical_and(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_coalesce(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_add(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_sub(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_mul(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_div(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_mod(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_pow(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_left_shift(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_right_shift(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_right_shift_ext(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_or(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_xor(&mut self) { + } + + fn visit_enum_compound_assignment_operator_variant_and(&mut self) { + } + + fn visit_binary_operator(&mut self, ast: &'alloc BinaryOperator) { + self.enter_binary_operator(ast); + match ast { + BinaryOperator::Equals { .. } => { + self.visit_enum_binary_operator_variant_equals() + } + BinaryOperator::NotEquals { .. } => { + self.visit_enum_binary_operator_variant_not_equals() + } + BinaryOperator::StrictEquals { .. } => { + self.visit_enum_binary_operator_variant_strict_equals() + } + BinaryOperator::StrictNotEquals { .. } => { + self.visit_enum_binary_operator_variant_strict_not_equals() + } + BinaryOperator::LessThan { .. } => { + self.visit_enum_binary_operator_variant_less_than() + } + BinaryOperator::LessThanOrEqual { .. } => { + self.visit_enum_binary_operator_variant_less_than_or_equal() + } + BinaryOperator::GreaterThan { .. } => { + self.visit_enum_binary_operator_variant_greater_than() + } + BinaryOperator::GreaterThanOrEqual { .. } => { + self.visit_enum_binary_operator_variant_greater_than_or_equal() + } + BinaryOperator::In { .. } => { + self.visit_enum_binary_operator_variant_in() + } + BinaryOperator::Instanceof { .. } => { + self.visit_enum_binary_operator_variant_instanceof() + } + BinaryOperator::LeftShift { .. } => { + self.visit_enum_binary_operator_variant_left_shift() + } + BinaryOperator::RightShift { .. } => { + self.visit_enum_binary_operator_variant_right_shift() + } + BinaryOperator::RightShiftExt { .. } => { + self.visit_enum_binary_operator_variant_right_shift_ext() + } + BinaryOperator::Add { .. } => { + self.visit_enum_binary_operator_variant_add() + } + BinaryOperator::Sub { .. } => { + self.visit_enum_binary_operator_variant_sub() + } + BinaryOperator::Mul { .. } => { + self.visit_enum_binary_operator_variant_mul() + } + BinaryOperator::Div { .. } => { + self.visit_enum_binary_operator_variant_div() + } + BinaryOperator::Mod { .. } => { + self.visit_enum_binary_operator_variant_mod() + } + BinaryOperator::Pow { .. } => { + self.visit_enum_binary_operator_variant_pow() + } + BinaryOperator::Comma { .. } => { + self.visit_enum_binary_operator_variant_comma() + } + BinaryOperator::Coalesce { .. } => { + self.visit_enum_binary_operator_variant_coalesce() + } + BinaryOperator::LogicalOr { .. } => { + self.visit_enum_binary_operator_variant_logical_or() + } + BinaryOperator::LogicalAnd { .. } => { + self.visit_enum_binary_operator_variant_logical_and() + } + BinaryOperator::BitwiseOr { .. } => { + self.visit_enum_binary_operator_variant_bitwise_or() + } + BinaryOperator::BitwiseXor { .. } => { + self.visit_enum_binary_operator_variant_bitwise_xor() + } + BinaryOperator::BitwiseAnd { .. } => { + self.visit_enum_binary_operator_variant_bitwise_and() + } + } + self.leave_binary_operator(ast); + } + + fn enter_binary_operator(&mut self, ast: &'alloc BinaryOperator) { + } + + fn leave_binary_operator(&mut self, ast: &'alloc BinaryOperator) { + } + + fn visit_enum_binary_operator_variant_equals(&mut self) { + } + + fn visit_enum_binary_operator_variant_not_equals(&mut self) { + } + + fn visit_enum_binary_operator_variant_strict_equals(&mut self) { + } + + fn visit_enum_binary_operator_variant_strict_not_equals(&mut self) { + } + + fn visit_enum_binary_operator_variant_less_than(&mut self) { + } + + fn visit_enum_binary_operator_variant_less_than_or_equal(&mut self) { + } + + fn visit_enum_binary_operator_variant_greater_than(&mut self) { + } + + fn visit_enum_binary_operator_variant_greater_than_or_equal(&mut self) { + } + + fn visit_enum_binary_operator_variant_in(&mut self) { + } + + fn visit_enum_binary_operator_variant_instanceof(&mut self) { + } + + fn visit_enum_binary_operator_variant_left_shift(&mut self) { + } + + fn visit_enum_binary_operator_variant_right_shift(&mut self) { + } + + fn visit_enum_binary_operator_variant_right_shift_ext(&mut self) { + } + + fn visit_enum_binary_operator_variant_add(&mut self) { + } + + fn visit_enum_binary_operator_variant_sub(&mut self) { + } + + fn visit_enum_binary_operator_variant_mul(&mut self) { + } + + fn visit_enum_binary_operator_variant_div(&mut self) { + } + + fn visit_enum_binary_operator_variant_mod(&mut self) { + } + + fn visit_enum_binary_operator_variant_pow(&mut self) { + } + + fn visit_enum_binary_operator_variant_comma(&mut self) { + } + + fn visit_enum_binary_operator_variant_coalesce(&mut self) { + } + + fn visit_enum_binary_operator_variant_logical_or(&mut self) { + } + + fn visit_enum_binary_operator_variant_logical_and(&mut self) { + } + + fn visit_enum_binary_operator_variant_bitwise_or(&mut self) { + } + + fn visit_enum_binary_operator_variant_bitwise_xor(&mut self) { + } + + fn visit_enum_binary_operator_variant_bitwise_and(&mut self) { + } + + fn visit_unary_operator(&mut self, ast: &'alloc UnaryOperator) { + self.enter_unary_operator(ast); + match ast { + UnaryOperator::Plus { .. } => { + self.visit_enum_unary_operator_variant_plus() + } + UnaryOperator::Minus { .. } => { + self.visit_enum_unary_operator_variant_minus() + } + UnaryOperator::LogicalNot { .. } => { + self.visit_enum_unary_operator_variant_logical_not() + } + UnaryOperator::BitwiseNot { .. } => { + self.visit_enum_unary_operator_variant_bitwise_not() + } + UnaryOperator::Typeof { .. } => { + self.visit_enum_unary_operator_variant_typeof() + } + UnaryOperator::Void { .. } => { + self.visit_enum_unary_operator_variant_void() + } + UnaryOperator::Delete { .. } => { + self.visit_enum_unary_operator_variant_delete() + } + } + self.leave_unary_operator(ast); + } + + fn enter_unary_operator(&mut self, ast: &'alloc UnaryOperator) { + } + + fn leave_unary_operator(&mut self, ast: &'alloc UnaryOperator) { + } + + fn visit_enum_unary_operator_variant_plus(&mut self) { + } + + fn visit_enum_unary_operator_variant_minus(&mut self) { + } + + fn visit_enum_unary_operator_variant_logical_not(&mut self) { + } + + fn visit_enum_unary_operator_variant_bitwise_not(&mut self) { + } + + fn visit_enum_unary_operator_variant_typeof(&mut self) { + } + + fn visit_enum_unary_operator_variant_void(&mut self) { + } + + fn visit_enum_unary_operator_variant_delete(&mut self) { + } + + fn visit_update_operator(&mut self, ast: &'alloc UpdateOperator) { + self.enter_update_operator(ast); + match ast { + UpdateOperator::Increment { .. } => { + self.visit_enum_update_operator_variant_increment() + } + UpdateOperator::Decrement { .. } => { + self.visit_enum_update_operator_variant_decrement() + } + } + self.leave_update_operator(ast); + } + + fn enter_update_operator(&mut self, ast: &'alloc UpdateOperator) { + } + + fn leave_update_operator(&mut self, ast: &'alloc UpdateOperator) { + } + + fn visit_enum_update_operator_variant_increment(&mut self) { + } + + fn visit_enum_update_operator_variant_decrement(&mut self) { + } + + fn visit_function(&mut self, ast: &'alloc Function<'alloc>) { + self.enter_function(ast); + if let Some(item) = &ast.name { + self.visit_binding_identifier(item); + } + self.visit_formal_parameters(&ast.params); + self.visit_function_body(&ast.body); + self.leave_function(ast); + } + + fn enter_function(&mut self, ast: &'alloc Function<'alloc>) { + } + + fn leave_function(&mut self, ast: &'alloc Function<'alloc>) { + } + + fn visit_program(&mut self, ast: &'alloc Program<'alloc>) { + self.enter_program(ast); + match ast { + Program::Module(ast) => { + self.visit_enum_program_variant_module(ast) + } + Program::Script(ast) => { + self.visit_enum_program_variant_script(ast) + } + } + self.leave_program(ast); + } + + fn enter_program(&mut self, ast: &'alloc Program<'alloc>) { + } + + fn leave_program(&mut self, ast: &'alloc Program<'alloc>) { + } + + fn visit_enum_program_variant_module( + &mut self, + ast: &'alloc Module<'alloc>, + ) { + self.enter_enum_program_variant_module(ast); + self.visit_module(ast); + self.leave_enum_program_variant_module(ast); + } + + fn enter_enum_program_variant_module( + &mut self, + ast: &'alloc Module<'alloc>, + ) { + } + + fn leave_enum_program_variant_module( + &mut self, + ast: &'alloc Module<'alloc>, + ) { + } + + fn visit_enum_program_variant_script( + &mut self, + ast: &'alloc Script<'alloc>, + ) { + self.enter_enum_program_variant_script(ast); + self.visit_script(ast); + self.leave_enum_program_variant_script(ast); + } + + fn enter_enum_program_variant_script( + &mut self, + ast: &'alloc Script<'alloc>, + ) { + } + + fn leave_enum_program_variant_script( + &mut self, + ast: &'alloc Script<'alloc>, + ) { + } + + fn visit_if_statement(&mut self, ast: &'alloc IfStatement<'alloc>) { + self.enter_if_statement(ast); + self.visit_expression(&ast.test); + self.visit_statement(&ast.consequent); + if let Some(item) = &ast.alternate { + self.visit_statement(item); + } + self.leave_if_statement(ast); + } + + fn enter_if_statement(&mut self, ast: &'alloc IfStatement<'alloc>) { + } + + fn leave_if_statement(&mut self, ast: &'alloc IfStatement<'alloc>) { + } + + fn visit_statement(&mut self, ast: &'alloc Statement<'alloc>) { + self.enter_statement(ast); + match ast { + Statement::BlockStatement { block, .. } => { + self.visit_enum_statement_variant_block_statement( + block, + ) + } + Statement::BreakStatement { label, .. } => { + self.visit_enum_statement_variant_break_statement( + label, + ) + } + Statement::ContinueStatement { label, .. } => { + self.visit_enum_statement_variant_continue_statement( + label, + ) + } + Statement::DebuggerStatement { .. } => { + self.visit_enum_statement_variant_debugger_statement() + } + Statement::DoWhileStatement { block, test, .. } => { + self.visit_enum_statement_variant_do_while_statement( + block, + test, + ) + } + Statement::EmptyStatement { .. } => { + self.visit_enum_statement_variant_empty_statement() + } + Statement::ExpressionStatement(ast) => { + self.visit_enum_statement_variant_expression_statement(ast) + } + Statement::ForInStatement { left, right, block, .. } => { + self.visit_enum_statement_variant_for_in_statement( + left, + right, + block, + ) + } + Statement::ForOfStatement { left, right, block, .. } => { + self.visit_enum_statement_variant_for_of_statement( + left, + right, + block, + ) + } + Statement::ForStatement { init, test, update, block, .. } => { + self.visit_enum_statement_variant_for_statement( + init, + test, + update, + block, + ) + } + Statement::IfStatement(ast) => { + self.visit_enum_statement_variant_if_statement(ast) + } + Statement::LabelledStatement { label, body, .. } => { + self.visit_enum_statement_variant_labelled_statement( + label, + body, + ) + } + Statement::ReturnStatement { expression, .. } => { + self.visit_enum_statement_variant_return_statement( + expression, + ) + } + Statement::SwitchStatement { discriminant, cases, .. } => { + self.visit_enum_statement_variant_switch_statement( + discriminant, + cases, + ) + } + Statement::SwitchStatementWithDefault { discriminant, pre_default_cases, default_case, post_default_cases, .. } => { + self.visit_enum_statement_variant_switch_statement_with_default( + discriminant, + pre_default_cases, + default_case, + post_default_cases, + ) + } + Statement::ThrowStatement { expression, .. } => { + self.visit_enum_statement_variant_throw_statement( + expression, + ) + } + Statement::TryCatchStatement { body, catch_clause, .. } => { + self.visit_enum_statement_variant_try_catch_statement( + body, + catch_clause, + ) + } + Statement::TryFinallyStatement { body, catch_clause, finalizer, .. } => { + self.visit_enum_statement_variant_try_finally_statement( + body, + catch_clause, + finalizer, + ) + } + Statement::WhileStatement { test, block, .. } => { + self.visit_enum_statement_variant_while_statement( + test, + block, + ) + } + Statement::WithStatement { object, body, .. } => { + self.visit_enum_statement_variant_with_statement( + object, + body, + ) + } + Statement::VariableDeclarationStatement(ast) => { + self.visit_enum_statement_variant_variable_declaration_statement(ast) + } + Statement::FunctionDeclaration(ast) => { + self.visit_enum_statement_variant_function_declaration(ast) + } + Statement::ClassDeclaration(ast) => { + self.visit_enum_statement_variant_class_declaration(ast) + } + } + self.leave_statement(ast); + } + + fn enter_statement(&mut self, ast: &'alloc Statement<'alloc>) { + } + + fn leave_statement(&mut self, ast: &'alloc Statement<'alloc>) { + } + + fn visit_enum_statement_variant_block_statement( + &mut self, + block: &'alloc Block<'alloc>, + ) { + self.enter_enum_statement_variant_block_statement( + block, + ); + self.visit_block(block); + self.leave_enum_statement_variant_block_statement( + block, + ); + } + + fn enter_enum_statement_variant_block_statement( + &mut self, + block: &'alloc Block<'alloc>, + ) { + } + + fn leave_enum_statement_variant_block_statement( + &mut self, + block: &'alloc Block<'alloc>, + ) { + } + + fn visit_enum_statement_variant_break_statement( + &mut self, + label: &'alloc Option<Label>, + ) { + self.enter_enum_statement_variant_break_statement( + label, + ); + if let Some(item) = label { + self.visit_label(item); + } + self.leave_enum_statement_variant_break_statement( + label, + ); + } + + fn enter_enum_statement_variant_break_statement( + &mut self, + label: &'alloc Option<Label>, + ) { + } + + fn leave_enum_statement_variant_break_statement( + &mut self, + label: &'alloc Option<Label>, + ) { + } + + fn visit_enum_statement_variant_continue_statement( + &mut self, + label: &'alloc Option<Label>, + ) { + self.enter_enum_statement_variant_continue_statement( + label, + ); + if let Some(item) = label { + self.visit_label(item); + } + self.leave_enum_statement_variant_continue_statement( + label, + ); + } + + fn enter_enum_statement_variant_continue_statement( + &mut self, + label: &'alloc Option<Label>, + ) { + } + + fn leave_enum_statement_variant_continue_statement( + &mut self, + label: &'alloc Option<Label>, + ) { + } + + fn visit_enum_statement_variant_debugger_statement(&mut self) { + } + + fn visit_enum_statement_variant_do_while_statement( + &mut self, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + test: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_statement_variant_do_while_statement( + block, + test, + ); + self.visit_statement(block); + self.visit_expression(test); + self.leave_enum_statement_variant_do_while_statement( + block, + test, + ); + } + + fn enter_enum_statement_variant_do_while_statement( + &mut self, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + test: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_do_while_statement( + &mut self, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + test: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_empty_statement(&mut self) { + } + + fn visit_enum_statement_variant_expression_statement( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_statement_variant_expression_statement(ast); + self.visit_expression(ast); + self.leave_enum_statement_variant_expression_statement(ast); + } + + fn enter_enum_statement_variant_expression_statement( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_expression_statement( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_for_in_statement( + &mut self, + left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>, + right: &'alloc arena::Box<'alloc, Expression<'alloc>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + self.enter_enum_statement_variant_for_in_statement( + left, + right, + block, + ); + self.visit_variable_declaration_or_assignment_target(left); + self.visit_expression(right); + self.visit_statement(block); + self.leave_enum_statement_variant_for_in_statement( + left, + right, + block, + ); + } + + fn enter_enum_statement_variant_for_in_statement( + &mut self, + left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>, + right: &'alloc arena::Box<'alloc, Expression<'alloc>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_for_in_statement( + &mut self, + left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>, + right: &'alloc arena::Box<'alloc, Expression<'alloc>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_for_of_statement( + &mut self, + left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>, + right: &'alloc arena::Box<'alloc, Expression<'alloc>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + self.enter_enum_statement_variant_for_of_statement( + left, + right, + block, + ); + self.visit_variable_declaration_or_assignment_target(left); + self.visit_expression(right); + self.visit_statement(block); + self.leave_enum_statement_variant_for_of_statement( + left, + right, + block, + ); + } + + fn enter_enum_statement_variant_for_of_statement( + &mut self, + left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>, + right: &'alloc arena::Box<'alloc, Expression<'alloc>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_for_of_statement( + &mut self, + left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>, + right: &'alloc arena::Box<'alloc, Expression<'alloc>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_for_statement( + &mut self, + init: &'alloc Option<VariableDeclarationOrExpression<'alloc>>, + test: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + update: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + self.enter_enum_statement_variant_for_statement( + init, + test, + update, + block, + ); + if let Some(item) = init { + self.visit_variable_declaration_or_expression(item); + } + if let Some(item) = test { + self.visit_expression(item); + } + if let Some(item) = update { + self.visit_expression(item); + } + self.visit_statement(block); + self.leave_enum_statement_variant_for_statement( + init, + test, + update, + block, + ); + } + + fn enter_enum_statement_variant_for_statement( + &mut self, + init: &'alloc Option<VariableDeclarationOrExpression<'alloc>>, + test: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + update: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_for_statement( + &mut self, + init: &'alloc Option<VariableDeclarationOrExpression<'alloc>>, + test: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + update: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_if_statement( + &mut self, + ast: &'alloc IfStatement<'alloc>, + ) { + self.enter_enum_statement_variant_if_statement(ast); + self.visit_if_statement(ast); + self.leave_enum_statement_variant_if_statement(ast); + } + + fn enter_enum_statement_variant_if_statement( + &mut self, + ast: &'alloc IfStatement<'alloc>, + ) { + } + + fn leave_enum_statement_variant_if_statement( + &mut self, + ast: &'alloc IfStatement<'alloc>, + ) { + } + + fn visit_enum_statement_variant_labelled_statement( + &mut self, + label: &'alloc Label, + body: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + self.enter_enum_statement_variant_labelled_statement( + label, + body, + ); + self.visit_label(label); + self.visit_statement(body); + self.leave_enum_statement_variant_labelled_statement( + label, + body, + ); + } + + fn enter_enum_statement_variant_labelled_statement( + &mut self, + label: &'alloc Label, + body: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_labelled_statement( + &mut self, + label: &'alloc Label, + body: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_return_statement( + &mut self, + expression: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + ) { + self.enter_enum_statement_variant_return_statement( + expression, + ); + if let Some(item) = expression { + self.visit_expression(item); + } + self.leave_enum_statement_variant_return_statement( + expression, + ); + } + + fn enter_enum_statement_variant_return_statement( + &mut self, + expression: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + ) { + } + + fn leave_enum_statement_variant_return_statement( + &mut self, + expression: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + ) { + } + + fn visit_enum_statement_variant_switch_statement( + &mut self, + discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>, + cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>, + ) { + self.enter_enum_statement_variant_switch_statement( + discriminant, + cases, + ); + self.visit_expression(discriminant); + for item in cases.iter() { + self.visit_switch_case(item); + } + self.leave_enum_statement_variant_switch_statement( + discriminant, + cases, + ); + } + + fn enter_enum_statement_variant_switch_statement( + &mut self, + discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>, + cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_switch_statement( + &mut self, + discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>, + cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_switch_statement_with_default( + &mut self, + discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>, + pre_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>, + default_case: &'alloc SwitchDefault<'alloc>, + post_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>, + ) { + self.enter_enum_statement_variant_switch_statement_with_default( + discriminant, + pre_default_cases, + default_case, + post_default_cases, + ); + self.visit_expression(discriminant); + for item in pre_default_cases.iter() { + self.visit_switch_case(item); + } + self.visit_switch_default(default_case); + for item in post_default_cases.iter() { + self.visit_switch_case(item); + } + self.leave_enum_statement_variant_switch_statement_with_default( + discriminant, + pre_default_cases, + default_case, + post_default_cases, + ); + } + + fn enter_enum_statement_variant_switch_statement_with_default( + &mut self, + discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>, + pre_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>, + default_case: &'alloc SwitchDefault<'alloc>, + post_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_switch_statement_with_default( + &mut self, + discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>, + pre_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>, + default_case: &'alloc SwitchDefault<'alloc>, + post_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_throw_statement( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_statement_variant_throw_statement( + expression, + ); + self.visit_expression(expression); + self.leave_enum_statement_variant_throw_statement( + expression, + ); + } + + fn enter_enum_statement_variant_throw_statement( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_throw_statement( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_try_catch_statement( + &mut self, + body: &'alloc Block<'alloc>, + catch_clause: &'alloc CatchClause<'alloc>, + ) { + self.enter_enum_statement_variant_try_catch_statement( + body, + catch_clause, + ); + self.visit_block(body); + self.visit_catch_clause(catch_clause); + self.leave_enum_statement_variant_try_catch_statement( + body, + catch_clause, + ); + } + + fn enter_enum_statement_variant_try_catch_statement( + &mut self, + body: &'alloc Block<'alloc>, + catch_clause: &'alloc CatchClause<'alloc>, + ) { + } + + fn leave_enum_statement_variant_try_catch_statement( + &mut self, + body: &'alloc Block<'alloc>, + catch_clause: &'alloc CatchClause<'alloc>, + ) { + } + + fn visit_enum_statement_variant_try_finally_statement( + &mut self, + body: &'alloc Block<'alloc>, + catch_clause: &'alloc Option<CatchClause<'alloc>>, + finalizer: &'alloc Block<'alloc>, + ) { + self.enter_enum_statement_variant_try_finally_statement( + body, + catch_clause, + finalizer, + ); + self.visit_block(body); + if let Some(item) = catch_clause { + self.visit_catch_clause(item); + } + self.visit_block(finalizer); + self.leave_enum_statement_variant_try_finally_statement( + body, + catch_clause, + finalizer, + ); + } + + fn enter_enum_statement_variant_try_finally_statement( + &mut self, + body: &'alloc Block<'alloc>, + catch_clause: &'alloc Option<CatchClause<'alloc>>, + finalizer: &'alloc Block<'alloc>, + ) { + } + + fn leave_enum_statement_variant_try_finally_statement( + &mut self, + body: &'alloc Block<'alloc>, + catch_clause: &'alloc Option<CatchClause<'alloc>>, + finalizer: &'alloc Block<'alloc>, + ) { + } + + fn visit_enum_statement_variant_while_statement( + &mut self, + test: &'alloc arena::Box<'alloc, Expression<'alloc>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + self.enter_enum_statement_variant_while_statement( + test, + block, + ); + self.visit_expression(test); + self.visit_statement(block); + self.leave_enum_statement_variant_while_statement( + test, + block, + ); + } + + fn enter_enum_statement_variant_while_statement( + &mut self, + test: &'alloc arena::Box<'alloc, Expression<'alloc>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_while_statement( + &mut self, + test: &'alloc arena::Box<'alloc, Expression<'alloc>>, + block: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_with_statement( + &mut self, + object: &'alloc arena::Box<'alloc, Expression<'alloc>>, + body: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + self.enter_enum_statement_variant_with_statement( + object, + body, + ); + self.visit_expression(object); + self.visit_statement(body); + self.leave_enum_statement_variant_with_statement( + object, + body, + ); + } + + fn enter_enum_statement_variant_with_statement( + &mut self, + object: &'alloc arena::Box<'alloc, Expression<'alloc>>, + body: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn leave_enum_statement_variant_with_statement( + &mut self, + object: &'alloc arena::Box<'alloc, Expression<'alloc>>, + body: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn visit_enum_statement_variant_variable_declaration_statement( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + self.enter_enum_statement_variant_variable_declaration_statement(ast); + self.visit_variable_declaration(ast); + self.leave_enum_statement_variant_variable_declaration_statement(ast); + } + + fn enter_enum_statement_variant_variable_declaration_statement( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + } + + fn leave_enum_statement_variant_variable_declaration_statement( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + } + + fn visit_enum_statement_variant_function_declaration( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + self.enter_enum_statement_variant_function_declaration(ast); + self.visit_function(ast); + self.leave_enum_statement_variant_function_declaration(ast); + } + + fn enter_enum_statement_variant_function_declaration( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + } + + fn leave_enum_statement_variant_function_declaration( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + } + + fn visit_enum_statement_variant_class_declaration( + &mut self, + ast: &'alloc ClassDeclaration<'alloc>, + ) { + self.enter_enum_statement_variant_class_declaration(ast); + self.visit_class_declaration(ast); + self.leave_enum_statement_variant_class_declaration(ast); + } + + fn enter_enum_statement_variant_class_declaration( + &mut self, + ast: &'alloc ClassDeclaration<'alloc>, + ) { + } + + fn leave_enum_statement_variant_class_declaration( + &mut self, + ast: &'alloc ClassDeclaration<'alloc>, + ) { + } + + fn visit_expression(&mut self, ast: &'alloc Expression<'alloc>) { + self.enter_expression(ast); + match ast { + Expression::MemberExpression(ast) => { + self.visit_enum_expression_variant_member_expression(ast) + } + Expression::ClassExpression(ast) => { + self.visit_enum_expression_variant_class_expression(ast) + } + Expression::LiteralBooleanExpression { value, .. } => { + self.visit_enum_expression_variant_literal_boolean_expression( + value, + ) + } + Expression::LiteralInfinityExpression { .. } => { + self.visit_enum_expression_variant_literal_infinity_expression() + } + Expression::LiteralNullExpression { .. } => { + self.visit_enum_expression_variant_literal_null_expression() + } + Expression::LiteralNumericExpression(ast) => { + self.visit_enum_expression_variant_literal_numeric_expression(ast) + } + Expression::LiteralRegExpExpression { pattern, global, ignore_case, multi_line, dot_all, sticky, unicode, .. } => { + self.visit_enum_expression_variant_literal_reg_exp_expression( + pattern, + global, + ignore_case, + multi_line, + dot_all, + sticky, + unicode, + ) + } + Expression::LiteralStringExpression { value, .. } => { + self.visit_enum_expression_variant_literal_string_expression( + value, + ) + } + Expression::ArrayExpression(ast) => { + self.visit_enum_expression_variant_array_expression(ast) + } + Expression::ArrowExpression { is_async, params, body, .. } => { + self.visit_enum_expression_variant_arrow_expression( + is_async, + params, + body, + ) + } + Expression::AssignmentExpression { binding, expression, .. } => { + self.visit_enum_expression_variant_assignment_expression( + binding, + expression, + ) + } + Expression::BinaryExpression { operator, left, right, .. } => { + self.visit_enum_expression_variant_binary_expression( + operator, + left, + right, + ) + } + Expression::CallExpression(ast) => { + self.visit_enum_expression_variant_call_expression(ast) + } + Expression::CompoundAssignmentExpression { operator, binding, expression, .. } => { + self.visit_enum_expression_variant_compound_assignment_expression( + operator, + binding, + expression, + ) + } + Expression::ConditionalExpression { test, consequent, alternate, .. } => { + self.visit_enum_expression_variant_conditional_expression( + test, + consequent, + alternate, + ) + } + Expression::FunctionExpression(ast) => { + self.visit_enum_expression_variant_function_expression(ast) + } + Expression::IdentifierExpression(ast) => { + self.visit_enum_expression_variant_identifier_expression(ast) + } + Expression::NewExpression { callee, arguments, .. } => { + self.visit_enum_expression_variant_new_expression( + callee, + arguments, + ) + } + Expression::NewTargetExpression { .. } => { + self.visit_enum_expression_variant_new_target_expression() + } + Expression::ObjectExpression(ast) => { + self.visit_enum_expression_variant_object_expression(ast) + } + Expression::OptionalExpression { object, tail, .. } => { + self.visit_enum_expression_variant_optional_expression( + object, + tail, + ) + } + Expression::OptionalChain(ast) => { + self.visit_enum_expression_variant_optional_chain(ast) + } + Expression::UnaryExpression { operator, operand, .. } => { + self.visit_enum_expression_variant_unary_expression( + operator, + operand, + ) + } + Expression::TemplateExpression(ast) => { + self.visit_enum_expression_variant_template_expression(ast) + } + Expression::ThisExpression { .. } => { + self.visit_enum_expression_variant_this_expression() + } + Expression::UpdateExpression { is_prefix, operator, operand, .. } => { + self.visit_enum_expression_variant_update_expression( + is_prefix, + operator, + operand, + ) + } + Expression::YieldExpression { expression, .. } => { + self.visit_enum_expression_variant_yield_expression( + expression, + ) + } + Expression::YieldGeneratorExpression { expression, .. } => { + self.visit_enum_expression_variant_yield_generator_expression( + expression, + ) + } + Expression::AwaitExpression { expression, .. } => { + self.visit_enum_expression_variant_await_expression( + expression, + ) + } + Expression::ImportCallExpression { argument, .. } => { + self.visit_enum_expression_variant_import_call_expression( + argument, + ) + } + } + self.leave_expression(ast); + } + + fn enter_expression(&mut self, ast: &'alloc Expression<'alloc>) { + } + + fn leave_expression(&mut self, ast: &'alloc Expression<'alloc>) { + } + + fn visit_enum_expression_variant_member_expression( + &mut self, + ast: &'alloc MemberExpression<'alloc>, + ) { + self.enter_enum_expression_variant_member_expression(ast); + self.visit_member_expression(ast); + self.leave_enum_expression_variant_member_expression(ast); + } + + fn enter_enum_expression_variant_member_expression( + &mut self, + ast: &'alloc MemberExpression<'alloc>, + ) { + } + + fn leave_enum_expression_variant_member_expression( + &mut self, + ast: &'alloc MemberExpression<'alloc>, + ) { + } + + fn visit_enum_expression_variant_class_expression( + &mut self, + ast: &'alloc ClassExpression<'alloc>, + ) { + self.enter_enum_expression_variant_class_expression(ast); + self.visit_class_expression(ast); + self.leave_enum_expression_variant_class_expression(ast); + } + + fn enter_enum_expression_variant_class_expression( + &mut self, + ast: &'alloc ClassExpression<'alloc>, + ) { + } + + fn leave_enum_expression_variant_class_expression( + &mut self, + ast: &'alloc ClassExpression<'alloc>, + ) { + } + + fn visit_enum_expression_variant_literal_boolean_expression( + &mut self, + value: &'alloc bool, + ) { + self.enter_enum_expression_variant_literal_boolean_expression( + value, + ); + self.leave_enum_expression_variant_literal_boolean_expression( + value, + ); + } + + fn enter_enum_expression_variant_literal_boolean_expression( + &mut self, + value: &'alloc bool, + ) { + } + + fn leave_enum_expression_variant_literal_boolean_expression( + &mut self, + value: &'alloc bool, + ) { + } + + fn visit_enum_expression_variant_literal_infinity_expression(&mut self) { + } + + fn visit_enum_expression_variant_literal_null_expression(&mut self) { + } + + fn visit_enum_expression_variant_literal_numeric_expression( + &mut self, + ast: &'alloc NumericLiteral, + ) { + self.enter_enum_expression_variant_literal_numeric_expression(ast); + self.visit_numeric_literal(ast); + self.leave_enum_expression_variant_literal_numeric_expression(ast); + } + + fn enter_enum_expression_variant_literal_numeric_expression( + &mut self, + ast: &'alloc NumericLiteral, + ) { + } + + fn leave_enum_expression_variant_literal_numeric_expression( + &mut self, + ast: &'alloc NumericLiteral, + ) { + } + + fn visit_enum_expression_variant_literal_reg_exp_expression( + &mut self, + pattern: &'alloc SourceSliceIndex, + global: &'alloc bool, + ignore_case: &'alloc bool, + multi_line: &'alloc bool, + dot_all: &'alloc bool, + sticky: &'alloc bool, + unicode: &'alloc bool, + ) { + self.enter_enum_expression_variant_literal_reg_exp_expression( + pattern, + global, + ignore_case, + multi_line, + dot_all, + sticky, + unicode, + ); + self.leave_enum_expression_variant_literal_reg_exp_expression( + pattern, + global, + ignore_case, + multi_line, + dot_all, + sticky, + unicode, + ); + } + + fn enter_enum_expression_variant_literal_reg_exp_expression( + &mut self, + pattern: &'alloc SourceSliceIndex, + global: &'alloc bool, + ignore_case: &'alloc bool, + multi_line: &'alloc bool, + dot_all: &'alloc bool, + sticky: &'alloc bool, + unicode: &'alloc bool, + ) { + } + + fn leave_enum_expression_variant_literal_reg_exp_expression( + &mut self, + pattern: &'alloc SourceSliceIndex, + global: &'alloc bool, + ignore_case: &'alloc bool, + multi_line: &'alloc bool, + dot_all: &'alloc bool, + sticky: &'alloc bool, + unicode: &'alloc bool, + ) { + } + + fn visit_enum_expression_variant_literal_string_expression( + &mut self, + value: &'alloc SourceAtomSetIndex, + ) { + self.enter_enum_expression_variant_literal_string_expression( + value, + ); + self.leave_enum_expression_variant_literal_string_expression( + value, + ); + } + + fn enter_enum_expression_variant_literal_string_expression( + &mut self, + value: &'alloc SourceAtomSetIndex, + ) { + } + + fn leave_enum_expression_variant_literal_string_expression( + &mut self, + value: &'alloc SourceAtomSetIndex, + ) { + } + + fn visit_enum_expression_variant_array_expression( + &mut self, + ast: &'alloc ArrayExpression<'alloc>, + ) { + self.enter_enum_expression_variant_array_expression(ast); + self.visit_array_expression(ast); + self.leave_enum_expression_variant_array_expression(ast); + } + + fn enter_enum_expression_variant_array_expression( + &mut self, + ast: &'alloc ArrayExpression<'alloc>, + ) { + } + + fn leave_enum_expression_variant_array_expression( + &mut self, + ast: &'alloc ArrayExpression<'alloc>, + ) { + } + + fn visit_enum_expression_variant_arrow_expression( + &mut self, + is_async: &'alloc bool, + params: &'alloc FormalParameters<'alloc>, + body: &'alloc ArrowExpressionBody<'alloc>, + ) { + self.enter_enum_expression_variant_arrow_expression( + is_async, + params, + body, + ); + self.visit_formal_parameters(params); + self.visit_arrow_expression_body(body); + self.leave_enum_expression_variant_arrow_expression( + is_async, + params, + body, + ); + } + + fn enter_enum_expression_variant_arrow_expression( + &mut self, + is_async: &'alloc bool, + params: &'alloc FormalParameters<'alloc>, + body: &'alloc ArrowExpressionBody<'alloc>, + ) { + } + + fn leave_enum_expression_variant_arrow_expression( + &mut self, + is_async: &'alloc bool, + params: &'alloc FormalParameters<'alloc>, + body: &'alloc ArrowExpressionBody<'alloc>, + ) { + } + + fn visit_enum_expression_variant_assignment_expression( + &mut self, + binding: &'alloc AssignmentTarget<'alloc>, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_variant_assignment_expression( + binding, + expression, + ); + self.visit_assignment_target(binding); + self.visit_expression(expression); + self.leave_enum_expression_variant_assignment_expression( + binding, + expression, + ); + } + + fn enter_enum_expression_variant_assignment_expression( + &mut self, + binding: &'alloc AssignmentTarget<'alloc>, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_variant_assignment_expression( + &mut self, + binding: &'alloc AssignmentTarget<'alloc>, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_expression_variant_binary_expression( + &mut self, + operator: &'alloc BinaryOperator, + left: &'alloc arena::Box<'alloc, Expression<'alloc>>, + right: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_variant_binary_expression( + operator, + left, + right, + ); + self.visit_binary_operator(operator); + self.visit_expression(left); + self.visit_expression(right); + self.leave_enum_expression_variant_binary_expression( + operator, + left, + right, + ); + } + + fn enter_enum_expression_variant_binary_expression( + &mut self, + operator: &'alloc BinaryOperator, + left: &'alloc arena::Box<'alloc, Expression<'alloc>>, + right: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_variant_binary_expression( + &mut self, + operator: &'alloc BinaryOperator, + left: &'alloc arena::Box<'alloc, Expression<'alloc>>, + right: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_expression_variant_call_expression( + &mut self, + ast: &'alloc CallExpression<'alloc>, + ) { + self.enter_enum_expression_variant_call_expression(ast); + self.visit_call_expression(ast); + self.leave_enum_expression_variant_call_expression(ast); + } + + fn enter_enum_expression_variant_call_expression( + &mut self, + ast: &'alloc CallExpression<'alloc>, + ) { + } + + fn leave_enum_expression_variant_call_expression( + &mut self, + ast: &'alloc CallExpression<'alloc>, + ) { + } + + fn visit_enum_expression_variant_compound_assignment_expression( + &mut self, + operator: &'alloc CompoundAssignmentOperator, + binding: &'alloc SimpleAssignmentTarget<'alloc>, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_variant_compound_assignment_expression( + operator, + binding, + expression, + ); + self.visit_compound_assignment_operator(operator); + self.visit_simple_assignment_target(binding); + self.visit_expression(expression); + self.leave_enum_expression_variant_compound_assignment_expression( + operator, + binding, + expression, + ); + } + + fn enter_enum_expression_variant_compound_assignment_expression( + &mut self, + operator: &'alloc CompoundAssignmentOperator, + binding: &'alloc SimpleAssignmentTarget<'alloc>, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_variant_compound_assignment_expression( + &mut self, + operator: &'alloc CompoundAssignmentOperator, + binding: &'alloc SimpleAssignmentTarget<'alloc>, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_expression_variant_conditional_expression( + &mut self, + test: &'alloc arena::Box<'alloc, Expression<'alloc>>, + consequent: &'alloc arena::Box<'alloc, Expression<'alloc>>, + alternate: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_variant_conditional_expression( + test, + consequent, + alternate, + ); + self.visit_expression(test); + self.visit_expression(consequent); + self.visit_expression(alternate); + self.leave_enum_expression_variant_conditional_expression( + test, + consequent, + alternate, + ); + } + + fn enter_enum_expression_variant_conditional_expression( + &mut self, + test: &'alloc arena::Box<'alloc, Expression<'alloc>>, + consequent: &'alloc arena::Box<'alloc, Expression<'alloc>>, + alternate: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_variant_conditional_expression( + &mut self, + test: &'alloc arena::Box<'alloc, Expression<'alloc>>, + consequent: &'alloc arena::Box<'alloc, Expression<'alloc>>, + alternate: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_expression_variant_function_expression( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + self.enter_enum_expression_variant_function_expression(ast); + self.visit_function(ast); + self.leave_enum_expression_variant_function_expression(ast); + } + + fn enter_enum_expression_variant_function_expression( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + } + + fn leave_enum_expression_variant_function_expression( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + } + + fn visit_enum_expression_variant_identifier_expression( + &mut self, + ast: &'alloc IdentifierExpression, + ) { + self.enter_enum_expression_variant_identifier_expression(ast); + self.visit_identifier_expression(ast); + self.leave_enum_expression_variant_identifier_expression(ast); + } + + fn enter_enum_expression_variant_identifier_expression( + &mut self, + ast: &'alloc IdentifierExpression, + ) { + } + + fn leave_enum_expression_variant_identifier_expression( + &mut self, + ast: &'alloc IdentifierExpression, + ) { + } + + fn visit_enum_expression_variant_new_expression( + &mut self, + callee: &'alloc arena::Box<'alloc, Expression<'alloc>>, + arguments: &'alloc Arguments<'alloc>, + ) { + self.enter_enum_expression_variant_new_expression( + callee, + arguments, + ); + self.visit_expression(callee); + self.visit_arguments(arguments); + self.leave_enum_expression_variant_new_expression( + callee, + arguments, + ); + } + + fn enter_enum_expression_variant_new_expression( + &mut self, + callee: &'alloc arena::Box<'alloc, Expression<'alloc>>, + arguments: &'alloc Arguments<'alloc>, + ) { + } + + fn leave_enum_expression_variant_new_expression( + &mut self, + callee: &'alloc arena::Box<'alloc, Expression<'alloc>>, + arguments: &'alloc Arguments<'alloc>, + ) { + } + + fn visit_enum_expression_variant_new_target_expression(&mut self) { + } + + fn visit_enum_expression_variant_object_expression( + &mut self, + ast: &'alloc ObjectExpression<'alloc>, + ) { + self.enter_enum_expression_variant_object_expression(ast); + self.visit_object_expression(ast); + self.leave_enum_expression_variant_object_expression(ast); + } + + fn enter_enum_expression_variant_object_expression( + &mut self, + ast: &'alloc ObjectExpression<'alloc>, + ) { + } + + fn leave_enum_expression_variant_object_expression( + &mut self, + ast: &'alloc ObjectExpression<'alloc>, + ) { + } + + fn visit_enum_expression_variant_optional_expression( + &mut self, + object: &'alloc ExpressionOrSuper<'alloc>, + tail: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_variant_optional_expression( + object, + tail, + ); + self.visit_expression_or_super(object); + self.visit_expression(tail); + self.leave_enum_expression_variant_optional_expression( + object, + tail, + ); + } + + fn enter_enum_expression_variant_optional_expression( + &mut self, + object: &'alloc ExpressionOrSuper<'alloc>, + tail: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_variant_optional_expression( + &mut self, + object: &'alloc ExpressionOrSuper<'alloc>, + tail: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_expression_variant_optional_chain( + &mut self, + ast: &'alloc OptionalChain<'alloc>, + ) { + self.enter_enum_expression_variant_optional_chain(ast); + self.visit_optional_chain(ast); + self.leave_enum_expression_variant_optional_chain(ast); + } + + fn enter_enum_expression_variant_optional_chain( + &mut self, + ast: &'alloc OptionalChain<'alloc>, + ) { + } + + fn leave_enum_expression_variant_optional_chain( + &mut self, + ast: &'alloc OptionalChain<'alloc>, + ) { + } + + fn visit_enum_expression_variant_unary_expression( + &mut self, + operator: &'alloc UnaryOperator, + operand: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_variant_unary_expression( + operator, + operand, + ); + self.visit_unary_operator(operator); + self.visit_expression(operand); + self.leave_enum_expression_variant_unary_expression( + operator, + operand, + ); + } + + fn enter_enum_expression_variant_unary_expression( + &mut self, + operator: &'alloc UnaryOperator, + operand: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_variant_unary_expression( + &mut self, + operator: &'alloc UnaryOperator, + operand: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_expression_variant_template_expression( + &mut self, + ast: &'alloc TemplateExpression<'alloc>, + ) { + self.enter_enum_expression_variant_template_expression(ast); + self.visit_template_expression(ast); + self.leave_enum_expression_variant_template_expression(ast); + } + + fn enter_enum_expression_variant_template_expression( + &mut self, + ast: &'alloc TemplateExpression<'alloc>, + ) { + } + + fn leave_enum_expression_variant_template_expression( + &mut self, + ast: &'alloc TemplateExpression<'alloc>, + ) { + } + + fn visit_enum_expression_variant_this_expression(&mut self) { + } + + fn visit_enum_expression_variant_update_expression( + &mut self, + is_prefix: &'alloc bool, + operator: &'alloc UpdateOperator, + operand: &'alloc SimpleAssignmentTarget<'alloc>, + ) { + self.enter_enum_expression_variant_update_expression( + is_prefix, + operator, + operand, + ); + self.visit_update_operator(operator); + self.visit_simple_assignment_target(operand); + self.leave_enum_expression_variant_update_expression( + is_prefix, + operator, + operand, + ); + } + + fn enter_enum_expression_variant_update_expression( + &mut self, + is_prefix: &'alloc bool, + operator: &'alloc UpdateOperator, + operand: &'alloc SimpleAssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_expression_variant_update_expression( + &mut self, + is_prefix: &'alloc bool, + operator: &'alloc UpdateOperator, + operand: &'alloc SimpleAssignmentTarget<'alloc>, + ) { + } + + fn visit_enum_expression_variant_yield_expression( + &mut self, + expression: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + ) { + self.enter_enum_expression_variant_yield_expression( + expression, + ); + if let Some(item) = expression { + self.visit_expression(item); + } + self.leave_enum_expression_variant_yield_expression( + expression, + ); + } + + fn enter_enum_expression_variant_yield_expression( + &mut self, + expression: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + ) { + } + + fn leave_enum_expression_variant_yield_expression( + &mut self, + expression: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + ) { + } + + fn visit_enum_expression_variant_yield_generator_expression( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_variant_yield_generator_expression( + expression, + ); + self.visit_expression(expression); + self.leave_enum_expression_variant_yield_generator_expression( + expression, + ); + } + + fn enter_enum_expression_variant_yield_generator_expression( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_variant_yield_generator_expression( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_expression_variant_await_expression( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_variant_await_expression( + expression, + ); + self.visit_expression(expression); + self.leave_enum_expression_variant_await_expression( + expression, + ); + } + + fn enter_enum_expression_variant_await_expression( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_variant_await_expression( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_expression_variant_import_call_expression( + &mut self, + argument: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_variant_import_call_expression( + argument, + ); + self.visit_expression(argument); + self.leave_enum_expression_variant_import_call_expression( + argument, + ); + } + + fn enter_enum_expression_variant_import_call_expression( + &mut self, + argument: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_variant_import_call_expression( + &mut self, + argument: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_member_expression(&mut self, ast: &'alloc MemberExpression<'alloc>) { + self.enter_member_expression(ast); + match ast { + MemberExpression::ComputedMemberExpression(ast) => { + self.visit_enum_member_expression_variant_computed_member_expression(ast) + } + MemberExpression::StaticMemberExpression(ast) => { + self.visit_enum_member_expression_variant_static_member_expression(ast) + } + MemberExpression::PrivateFieldExpression(ast) => { + self.visit_enum_member_expression_variant_private_field_expression(ast) + } + } + self.leave_member_expression(ast); + } + + fn enter_member_expression(&mut self, ast: &'alloc MemberExpression<'alloc>) { + } + + fn leave_member_expression(&mut self, ast: &'alloc MemberExpression<'alloc>) { + } + + fn visit_enum_member_expression_variant_computed_member_expression( + &mut self, + ast: &'alloc ComputedMemberExpression<'alloc>, + ) { + self.enter_enum_member_expression_variant_computed_member_expression(ast); + self.visit_computed_member_expression(ast); + self.leave_enum_member_expression_variant_computed_member_expression(ast); + } + + fn enter_enum_member_expression_variant_computed_member_expression( + &mut self, + ast: &'alloc ComputedMemberExpression<'alloc>, + ) { + } + + fn leave_enum_member_expression_variant_computed_member_expression( + &mut self, + ast: &'alloc ComputedMemberExpression<'alloc>, + ) { + } + + fn visit_enum_member_expression_variant_static_member_expression( + &mut self, + ast: &'alloc StaticMemberExpression<'alloc>, + ) { + self.enter_enum_member_expression_variant_static_member_expression(ast); + self.visit_static_member_expression(ast); + self.leave_enum_member_expression_variant_static_member_expression(ast); + } + + fn enter_enum_member_expression_variant_static_member_expression( + &mut self, + ast: &'alloc StaticMemberExpression<'alloc>, + ) { + } + + fn leave_enum_member_expression_variant_static_member_expression( + &mut self, + ast: &'alloc StaticMemberExpression<'alloc>, + ) { + } + + fn visit_enum_member_expression_variant_private_field_expression( + &mut self, + ast: &'alloc PrivateFieldExpression<'alloc>, + ) { + self.enter_enum_member_expression_variant_private_field_expression(ast); + self.visit_private_field_expression(ast); + self.leave_enum_member_expression_variant_private_field_expression(ast); + } + + fn enter_enum_member_expression_variant_private_field_expression( + &mut self, + ast: &'alloc PrivateFieldExpression<'alloc>, + ) { + } + + fn leave_enum_member_expression_variant_private_field_expression( + &mut self, + ast: &'alloc PrivateFieldExpression<'alloc>, + ) { + } + + fn visit_optional_chain(&mut self, ast: &'alloc OptionalChain<'alloc>) { + self.enter_optional_chain(ast); + match ast { + OptionalChain::ComputedMemberExpressionTail { expression, .. } => { + self.visit_enum_optional_chain_variant_computed_member_expression_tail( + expression, + ) + } + OptionalChain::StaticMemberExpressionTail { property, .. } => { + self.visit_enum_optional_chain_variant_static_member_expression_tail( + property, + ) + } + OptionalChain::PrivateFieldExpressionTail { field, .. } => { + self.visit_enum_optional_chain_variant_private_field_expression_tail( + field, + ) + } + OptionalChain::CallExpressionTail { arguments, .. } => { + self.visit_enum_optional_chain_variant_call_expression_tail( + arguments, + ) + } + OptionalChain::ComputedMemberExpression(ast) => { + self.visit_enum_optional_chain_variant_computed_member_expression(ast) + } + OptionalChain::StaticMemberExpression(ast) => { + self.visit_enum_optional_chain_variant_static_member_expression(ast) + } + OptionalChain::PrivateFieldExpression(ast) => { + self.visit_enum_optional_chain_variant_private_field_expression(ast) + } + OptionalChain::CallExpression(ast) => { + self.visit_enum_optional_chain_variant_call_expression(ast) + } + } + self.leave_optional_chain(ast); + } + + fn enter_optional_chain(&mut self, ast: &'alloc OptionalChain<'alloc>) { + } + + fn leave_optional_chain(&mut self, ast: &'alloc OptionalChain<'alloc>) { + } + + fn visit_enum_optional_chain_variant_computed_member_expression_tail( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_optional_chain_variant_computed_member_expression_tail( + expression, + ); + self.visit_expression(expression); + self.leave_enum_optional_chain_variant_computed_member_expression_tail( + expression, + ); + } + + fn enter_enum_optional_chain_variant_computed_member_expression_tail( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_optional_chain_variant_computed_member_expression_tail( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_optional_chain_variant_static_member_expression_tail( + &mut self, + property: &'alloc IdentifierName, + ) { + self.enter_enum_optional_chain_variant_static_member_expression_tail( + property, + ); + self.visit_identifier_name(property); + self.leave_enum_optional_chain_variant_static_member_expression_tail( + property, + ); + } + + fn enter_enum_optional_chain_variant_static_member_expression_tail( + &mut self, + property: &'alloc IdentifierName, + ) { + } + + fn leave_enum_optional_chain_variant_static_member_expression_tail( + &mut self, + property: &'alloc IdentifierName, + ) { + } + + fn visit_enum_optional_chain_variant_private_field_expression_tail( + &mut self, + field: &'alloc PrivateIdentifier, + ) { + self.enter_enum_optional_chain_variant_private_field_expression_tail( + field, + ); + self.visit_private_identifier(field); + self.leave_enum_optional_chain_variant_private_field_expression_tail( + field, + ); + } + + fn enter_enum_optional_chain_variant_private_field_expression_tail( + &mut self, + field: &'alloc PrivateIdentifier, + ) { + } + + fn leave_enum_optional_chain_variant_private_field_expression_tail( + &mut self, + field: &'alloc PrivateIdentifier, + ) { + } + + fn visit_enum_optional_chain_variant_call_expression_tail( + &mut self, + arguments: &'alloc Arguments<'alloc>, + ) { + self.enter_enum_optional_chain_variant_call_expression_tail( + arguments, + ); + self.visit_arguments(arguments); + self.leave_enum_optional_chain_variant_call_expression_tail( + arguments, + ); + } + + fn enter_enum_optional_chain_variant_call_expression_tail( + &mut self, + arguments: &'alloc Arguments<'alloc>, + ) { + } + + fn leave_enum_optional_chain_variant_call_expression_tail( + &mut self, + arguments: &'alloc Arguments<'alloc>, + ) { + } + + fn visit_enum_optional_chain_variant_computed_member_expression( + &mut self, + ast: &'alloc ComputedMemberExpression<'alloc>, + ) { + self.enter_enum_optional_chain_variant_computed_member_expression(ast); + self.visit_computed_member_expression(ast); + self.leave_enum_optional_chain_variant_computed_member_expression(ast); + } + + fn enter_enum_optional_chain_variant_computed_member_expression( + &mut self, + ast: &'alloc ComputedMemberExpression<'alloc>, + ) { + } + + fn leave_enum_optional_chain_variant_computed_member_expression( + &mut self, + ast: &'alloc ComputedMemberExpression<'alloc>, + ) { + } + + fn visit_enum_optional_chain_variant_static_member_expression( + &mut self, + ast: &'alloc StaticMemberExpression<'alloc>, + ) { + self.enter_enum_optional_chain_variant_static_member_expression(ast); + self.visit_static_member_expression(ast); + self.leave_enum_optional_chain_variant_static_member_expression(ast); + } + + fn enter_enum_optional_chain_variant_static_member_expression( + &mut self, + ast: &'alloc StaticMemberExpression<'alloc>, + ) { + } + + fn leave_enum_optional_chain_variant_static_member_expression( + &mut self, + ast: &'alloc StaticMemberExpression<'alloc>, + ) { + } + + fn visit_enum_optional_chain_variant_private_field_expression( + &mut self, + ast: &'alloc PrivateFieldExpression<'alloc>, + ) { + self.enter_enum_optional_chain_variant_private_field_expression(ast); + self.visit_private_field_expression(ast); + self.leave_enum_optional_chain_variant_private_field_expression(ast); + } + + fn enter_enum_optional_chain_variant_private_field_expression( + &mut self, + ast: &'alloc PrivateFieldExpression<'alloc>, + ) { + } + + fn leave_enum_optional_chain_variant_private_field_expression( + &mut self, + ast: &'alloc PrivateFieldExpression<'alloc>, + ) { + } + + fn visit_enum_optional_chain_variant_call_expression( + &mut self, + ast: &'alloc CallExpression<'alloc>, + ) { + self.enter_enum_optional_chain_variant_call_expression(ast); + self.visit_call_expression(ast); + self.leave_enum_optional_chain_variant_call_expression(ast); + } + + fn enter_enum_optional_chain_variant_call_expression( + &mut self, + ast: &'alloc CallExpression<'alloc>, + ) { + } + + fn leave_enum_optional_chain_variant_call_expression( + &mut self, + ast: &'alloc CallExpression<'alloc>, + ) { + } + + fn visit_property_name(&mut self, ast: &'alloc PropertyName<'alloc>) { + self.enter_property_name(ast); + match ast { + PropertyName::ComputedPropertyName(ast) => { + self.visit_enum_property_name_variant_computed_property_name(ast) + } + PropertyName::StaticPropertyName(ast) => { + self.visit_enum_property_name_variant_static_property_name(ast) + } + PropertyName::StaticNumericPropertyName(ast) => { + self.visit_enum_property_name_variant_static_numeric_property_name(ast) + } + } + self.leave_property_name(ast); + } + + fn enter_property_name(&mut self, ast: &'alloc PropertyName<'alloc>) { + } + + fn leave_property_name(&mut self, ast: &'alloc PropertyName<'alloc>) { + } + + fn visit_enum_property_name_variant_computed_property_name( + &mut self, + ast: &'alloc ComputedPropertyName<'alloc>, + ) { + self.enter_enum_property_name_variant_computed_property_name(ast); + self.visit_computed_property_name(ast); + self.leave_enum_property_name_variant_computed_property_name(ast); + } + + fn enter_enum_property_name_variant_computed_property_name( + &mut self, + ast: &'alloc ComputedPropertyName<'alloc>, + ) { + } + + fn leave_enum_property_name_variant_computed_property_name( + &mut self, + ast: &'alloc ComputedPropertyName<'alloc>, + ) { + } + + fn visit_enum_property_name_variant_static_property_name( + &mut self, + ast: &'alloc StaticPropertyName, + ) { + self.enter_enum_property_name_variant_static_property_name(ast); + self.visit_static_property_name(ast); + self.leave_enum_property_name_variant_static_property_name(ast); + } + + fn enter_enum_property_name_variant_static_property_name( + &mut self, + ast: &'alloc StaticPropertyName, + ) { + } + + fn leave_enum_property_name_variant_static_property_name( + &mut self, + ast: &'alloc StaticPropertyName, + ) { + } + + fn visit_enum_property_name_variant_static_numeric_property_name( + &mut self, + ast: &'alloc NumericLiteral, + ) { + self.enter_enum_property_name_variant_static_numeric_property_name(ast); + self.visit_numeric_literal(ast); + self.leave_enum_property_name_variant_static_numeric_property_name(ast); + } + + fn enter_enum_property_name_variant_static_numeric_property_name( + &mut self, + ast: &'alloc NumericLiteral, + ) { + } + + fn leave_enum_property_name_variant_static_numeric_property_name( + &mut self, + ast: &'alloc NumericLiteral, + ) { + } + + fn visit_call_expression(&mut self, ast: &'alloc CallExpression<'alloc>) { + self.enter_call_expression(ast); + self.visit_expression_or_super(&ast.callee); + self.visit_arguments(&ast.arguments); + self.leave_call_expression(ast); + } + + fn enter_call_expression(&mut self, ast: &'alloc CallExpression<'alloc>) { + } + + fn leave_call_expression(&mut self, ast: &'alloc CallExpression<'alloc>) { + } + + fn visit_class_element_name(&mut self, ast: &'alloc ClassElementName<'alloc>) { + self.enter_class_element_name(ast); + match ast { + ClassElementName::ComputedPropertyName(ast) => { + self.visit_enum_class_element_name_variant_computed_property_name(ast) + } + ClassElementName::StaticPropertyName(ast) => { + self.visit_enum_class_element_name_variant_static_property_name(ast) + } + ClassElementName::StaticNumericPropertyName(ast) => { + self.visit_enum_class_element_name_variant_static_numeric_property_name(ast) + } + ClassElementName::PrivateFieldName(ast) => { + self.visit_enum_class_element_name_variant_private_field_name(ast) + } + } + self.leave_class_element_name(ast); + } + + fn enter_class_element_name(&mut self, ast: &'alloc ClassElementName<'alloc>) { + } + + fn leave_class_element_name(&mut self, ast: &'alloc ClassElementName<'alloc>) { + } + + fn visit_enum_class_element_name_variant_computed_property_name( + &mut self, + ast: &'alloc ComputedPropertyName<'alloc>, + ) { + self.enter_enum_class_element_name_variant_computed_property_name(ast); + self.visit_computed_property_name(ast); + self.leave_enum_class_element_name_variant_computed_property_name(ast); + } + + fn enter_enum_class_element_name_variant_computed_property_name( + &mut self, + ast: &'alloc ComputedPropertyName<'alloc>, + ) { + } + + fn leave_enum_class_element_name_variant_computed_property_name( + &mut self, + ast: &'alloc ComputedPropertyName<'alloc>, + ) { + } + + fn visit_enum_class_element_name_variant_static_property_name( + &mut self, + ast: &'alloc StaticPropertyName, + ) { + self.enter_enum_class_element_name_variant_static_property_name(ast); + self.visit_static_property_name(ast); + self.leave_enum_class_element_name_variant_static_property_name(ast); + } + + fn enter_enum_class_element_name_variant_static_property_name( + &mut self, + ast: &'alloc StaticPropertyName, + ) { + } + + fn leave_enum_class_element_name_variant_static_property_name( + &mut self, + ast: &'alloc StaticPropertyName, + ) { + } + + fn visit_enum_class_element_name_variant_static_numeric_property_name( + &mut self, + ast: &'alloc NumericLiteral, + ) { + self.enter_enum_class_element_name_variant_static_numeric_property_name(ast); + self.visit_numeric_literal(ast); + self.leave_enum_class_element_name_variant_static_numeric_property_name(ast); + } + + fn enter_enum_class_element_name_variant_static_numeric_property_name( + &mut self, + ast: &'alloc NumericLiteral, + ) { + } + + fn leave_enum_class_element_name_variant_static_numeric_property_name( + &mut self, + ast: &'alloc NumericLiteral, + ) { + } + + fn visit_enum_class_element_name_variant_private_field_name( + &mut self, + ast: &'alloc PrivateIdentifier, + ) { + self.enter_enum_class_element_name_variant_private_field_name(ast); + self.visit_private_identifier(ast); + self.leave_enum_class_element_name_variant_private_field_name(ast); + } + + fn enter_enum_class_element_name_variant_private_field_name( + &mut self, + ast: &'alloc PrivateIdentifier, + ) { + } + + fn leave_enum_class_element_name_variant_private_field_name( + &mut self, + ast: &'alloc PrivateIdentifier, + ) { + } + + fn visit_object_property(&mut self, ast: &'alloc ObjectProperty<'alloc>) { + self.enter_object_property(ast); + match ast { + ObjectProperty::NamedObjectProperty(ast) => { + self.visit_enum_object_property_variant_named_object_property(ast) + } + ObjectProperty::ShorthandProperty(ast) => { + self.visit_enum_object_property_variant_shorthand_property(ast) + } + ObjectProperty::SpreadProperty(ast) => { + self.visit_enum_object_property_variant_spread_property(ast) + } + } + self.leave_object_property(ast); + } + + fn enter_object_property(&mut self, ast: &'alloc ObjectProperty<'alloc>) { + } + + fn leave_object_property(&mut self, ast: &'alloc ObjectProperty<'alloc>) { + } + + fn visit_enum_object_property_variant_named_object_property( + &mut self, + ast: &'alloc NamedObjectProperty<'alloc>, + ) { + self.enter_enum_object_property_variant_named_object_property(ast); + self.visit_named_object_property(ast); + self.leave_enum_object_property_variant_named_object_property(ast); + } + + fn enter_enum_object_property_variant_named_object_property( + &mut self, + ast: &'alloc NamedObjectProperty<'alloc>, + ) { + } + + fn leave_enum_object_property_variant_named_object_property( + &mut self, + ast: &'alloc NamedObjectProperty<'alloc>, + ) { + } + + fn visit_enum_object_property_variant_shorthand_property( + &mut self, + ast: &'alloc ShorthandProperty, + ) { + self.enter_enum_object_property_variant_shorthand_property(ast); + self.visit_shorthand_property(ast); + self.leave_enum_object_property_variant_shorthand_property(ast); + } + + fn enter_enum_object_property_variant_shorthand_property( + &mut self, + ast: &'alloc ShorthandProperty, + ) { + } + + fn leave_enum_object_property_variant_shorthand_property( + &mut self, + ast: &'alloc ShorthandProperty, + ) { + } + + fn visit_enum_object_property_variant_spread_property( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_object_property_variant_spread_property(ast); + self.visit_expression(ast); + self.leave_enum_object_property_variant_spread_property(ast); + } + + fn enter_enum_object_property_variant_spread_property( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_object_property_variant_spread_property( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_named_object_property(&mut self, ast: &'alloc NamedObjectProperty<'alloc>) { + self.enter_named_object_property(ast); + match ast { + NamedObjectProperty::MethodDefinition(ast) => { + self.visit_enum_named_object_property_variant_method_definition(ast) + } + NamedObjectProperty::DataProperty(ast) => { + self.visit_enum_named_object_property_variant_data_property(ast) + } + } + self.leave_named_object_property(ast); + } + + fn enter_named_object_property(&mut self, ast: &'alloc NamedObjectProperty<'alloc>) { + } + + fn leave_named_object_property(&mut self, ast: &'alloc NamedObjectProperty<'alloc>) { + } + + fn visit_enum_named_object_property_variant_method_definition( + &mut self, + ast: &'alloc MethodDefinition<'alloc>, + ) { + self.enter_enum_named_object_property_variant_method_definition(ast); + self.visit_method_definition(ast); + self.leave_enum_named_object_property_variant_method_definition(ast); + } + + fn enter_enum_named_object_property_variant_method_definition( + &mut self, + ast: &'alloc MethodDefinition<'alloc>, + ) { + } + + fn leave_enum_named_object_property_variant_method_definition( + &mut self, + ast: &'alloc MethodDefinition<'alloc>, + ) { + } + + fn visit_enum_named_object_property_variant_data_property( + &mut self, + ast: &'alloc DataProperty<'alloc>, + ) { + self.enter_enum_named_object_property_variant_data_property(ast); + self.visit_data_property(ast); + self.leave_enum_named_object_property_variant_data_property(ast); + } + + fn enter_enum_named_object_property_variant_data_property( + &mut self, + ast: &'alloc DataProperty<'alloc>, + ) { + } + + fn leave_enum_named_object_property_variant_data_property( + &mut self, + ast: &'alloc DataProperty<'alloc>, + ) { + } + + fn visit_method_definition(&mut self, ast: &'alloc MethodDefinition<'alloc>) { + self.enter_method_definition(ast); + match ast { + MethodDefinition::Method(ast) => { + self.visit_enum_method_definition_variant_method(ast) + } + MethodDefinition::Getter(ast) => { + self.visit_enum_method_definition_variant_getter(ast) + } + MethodDefinition::Setter(ast) => { + self.visit_enum_method_definition_variant_setter(ast) + } + } + self.leave_method_definition(ast); + } + + fn enter_method_definition(&mut self, ast: &'alloc MethodDefinition<'alloc>) { + } + + fn leave_method_definition(&mut self, ast: &'alloc MethodDefinition<'alloc>) { + } + + fn visit_enum_method_definition_variant_method( + &mut self, + ast: &'alloc Method<'alloc>, + ) { + self.enter_enum_method_definition_variant_method(ast); + self.visit_method(ast); + self.leave_enum_method_definition_variant_method(ast); + } + + fn enter_enum_method_definition_variant_method( + &mut self, + ast: &'alloc Method<'alloc>, + ) { + } + + fn leave_enum_method_definition_variant_method( + &mut self, + ast: &'alloc Method<'alloc>, + ) { + } + + fn visit_enum_method_definition_variant_getter( + &mut self, + ast: &'alloc Getter<'alloc>, + ) { + self.enter_enum_method_definition_variant_getter(ast); + self.visit_getter(ast); + self.leave_enum_method_definition_variant_getter(ast); + } + + fn enter_enum_method_definition_variant_getter( + &mut self, + ast: &'alloc Getter<'alloc>, + ) { + } + + fn leave_enum_method_definition_variant_getter( + &mut self, + ast: &'alloc Getter<'alloc>, + ) { + } + + fn visit_enum_method_definition_variant_setter( + &mut self, + ast: &'alloc Setter<'alloc>, + ) { + self.enter_enum_method_definition_variant_setter(ast); + self.visit_setter(ast); + self.leave_enum_method_definition_variant_setter(ast); + } + + fn enter_enum_method_definition_variant_setter( + &mut self, + ast: &'alloc Setter<'alloc>, + ) { + } + + fn leave_enum_method_definition_variant_setter( + &mut self, + ast: &'alloc Setter<'alloc>, + ) { + } + + fn visit_import_declaration(&mut self, ast: &'alloc ImportDeclaration<'alloc>) { + self.enter_import_declaration(ast); + match ast { + ImportDeclaration::Import(ast) => { + self.visit_enum_import_declaration_variant_import(ast) + } + ImportDeclaration::ImportNamespace(ast) => { + self.visit_enum_import_declaration_variant_import_namespace(ast) + } + } + self.leave_import_declaration(ast); + } + + fn enter_import_declaration(&mut self, ast: &'alloc ImportDeclaration<'alloc>) { + } + + fn leave_import_declaration(&mut self, ast: &'alloc ImportDeclaration<'alloc>) { + } + + fn visit_enum_import_declaration_variant_import( + &mut self, + ast: &'alloc Import<'alloc>, + ) { + self.enter_enum_import_declaration_variant_import(ast); + self.visit_import(ast); + self.leave_enum_import_declaration_variant_import(ast); + } + + fn enter_enum_import_declaration_variant_import( + &mut self, + ast: &'alloc Import<'alloc>, + ) { + } + + fn leave_enum_import_declaration_variant_import( + &mut self, + ast: &'alloc Import<'alloc>, + ) { + } + + fn visit_enum_import_declaration_variant_import_namespace( + &mut self, + ast: &'alloc ImportNamespace, + ) { + self.enter_enum_import_declaration_variant_import_namespace(ast); + self.visit_import_namespace(ast); + self.leave_enum_import_declaration_variant_import_namespace(ast); + } + + fn enter_enum_import_declaration_variant_import_namespace( + &mut self, + ast: &'alloc ImportNamespace, + ) { + } + + fn leave_enum_import_declaration_variant_import_namespace( + &mut self, + ast: &'alloc ImportNamespace, + ) { + } + + fn visit_export_declaration(&mut self, ast: &'alloc ExportDeclaration<'alloc>) { + self.enter_export_declaration(ast); + match ast { + ExportDeclaration::ExportAllFrom(ast) => { + self.visit_enum_export_declaration_variant_export_all_from(ast) + } + ExportDeclaration::ExportFrom(ast) => { + self.visit_enum_export_declaration_variant_export_from(ast) + } + ExportDeclaration::ExportLocals(ast) => { + self.visit_enum_export_declaration_variant_export_locals(ast) + } + ExportDeclaration::Export(ast) => { + self.visit_enum_export_declaration_variant_export(ast) + } + ExportDeclaration::ExportDefault(ast) => { + self.visit_enum_export_declaration_variant_export_default(ast) + } + } + self.leave_export_declaration(ast); + } + + fn enter_export_declaration(&mut self, ast: &'alloc ExportDeclaration<'alloc>) { + } + + fn leave_export_declaration(&mut self, ast: &'alloc ExportDeclaration<'alloc>) { + } + + fn visit_enum_export_declaration_variant_export_all_from( + &mut self, + ast: &'alloc ExportAllFrom, + ) { + self.enter_enum_export_declaration_variant_export_all_from(ast); + self.visit_export_all_from(ast); + self.leave_enum_export_declaration_variant_export_all_from(ast); + } + + fn enter_enum_export_declaration_variant_export_all_from( + &mut self, + ast: &'alloc ExportAllFrom, + ) { + } + + fn leave_enum_export_declaration_variant_export_all_from( + &mut self, + ast: &'alloc ExportAllFrom, + ) { + } + + fn visit_enum_export_declaration_variant_export_from( + &mut self, + ast: &'alloc ExportFrom<'alloc>, + ) { + self.enter_enum_export_declaration_variant_export_from(ast); + self.visit_export_from(ast); + self.leave_enum_export_declaration_variant_export_from(ast); + } + + fn enter_enum_export_declaration_variant_export_from( + &mut self, + ast: &'alloc ExportFrom<'alloc>, + ) { + } + + fn leave_enum_export_declaration_variant_export_from( + &mut self, + ast: &'alloc ExportFrom<'alloc>, + ) { + } + + fn visit_enum_export_declaration_variant_export_locals( + &mut self, + ast: &'alloc ExportLocals<'alloc>, + ) { + self.enter_enum_export_declaration_variant_export_locals(ast); + self.visit_export_locals(ast); + self.leave_enum_export_declaration_variant_export_locals(ast); + } + + fn enter_enum_export_declaration_variant_export_locals( + &mut self, + ast: &'alloc ExportLocals<'alloc>, + ) { + } + + fn leave_enum_export_declaration_variant_export_locals( + &mut self, + ast: &'alloc ExportLocals<'alloc>, + ) { + } + + fn visit_enum_export_declaration_variant_export( + &mut self, + ast: &'alloc Export<'alloc>, + ) { + self.enter_enum_export_declaration_variant_export(ast); + self.visit_export(ast); + self.leave_enum_export_declaration_variant_export(ast); + } + + fn enter_enum_export_declaration_variant_export( + &mut self, + ast: &'alloc Export<'alloc>, + ) { + } + + fn leave_enum_export_declaration_variant_export( + &mut self, + ast: &'alloc Export<'alloc>, + ) { + } + + fn visit_enum_export_declaration_variant_export_default( + &mut self, + ast: &'alloc ExportDefault<'alloc>, + ) { + self.enter_enum_export_declaration_variant_export_default(ast); + self.visit_export_default(ast); + self.leave_enum_export_declaration_variant_export_default(ast); + } + + fn enter_enum_export_declaration_variant_export_default( + &mut self, + ast: &'alloc ExportDefault<'alloc>, + ) { + } + + fn leave_enum_export_declaration_variant_export_default( + &mut self, + ast: &'alloc ExportDefault<'alloc>, + ) { + } + + fn visit_variable_reference(&mut self, ast: &'alloc VariableReference) { + self.enter_variable_reference(ast); + match ast { + VariableReference::BindingIdentifier(ast) => { + self.visit_enum_variable_reference_variant_binding_identifier(ast) + } + VariableReference::AssignmentTargetIdentifier(ast) => { + self.visit_enum_variable_reference_variant_assignment_target_identifier(ast) + } + } + self.leave_variable_reference(ast); + } + + fn enter_variable_reference(&mut self, ast: &'alloc VariableReference) { + } + + fn leave_variable_reference(&mut self, ast: &'alloc VariableReference) { + } + + fn visit_enum_variable_reference_variant_binding_identifier( + &mut self, + ast: &'alloc BindingIdentifier, + ) { + self.enter_enum_variable_reference_variant_binding_identifier(ast); + self.visit_binding_identifier(ast); + self.leave_enum_variable_reference_variant_binding_identifier(ast); + } + + fn enter_enum_variable_reference_variant_binding_identifier( + &mut self, + ast: &'alloc BindingIdentifier, + ) { + } + + fn leave_enum_variable_reference_variant_binding_identifier( + &mut self, + ast: &'alloc BindingIdentifier, + ) { + } + + fn visit_enum_variable_reference_variant_assignment_target_identifier( + &mut self, + ast: &'alloc AssignmentTargetIdentifier, + ) { + self.enter_enum_variable_reference_variant_assignment_target_identifier(ast); + self.visit_assignment_target_identifier(ast); + self.leave_enum_variable_reference_variant_assignment_target_identifier(ast); + } + + fn enter_enum_variable_reference_variant_assignment_target_identifier( + &mut self, + ast: &'alloc AssignmentTargetIdentifier, + ) { + } + + fn leave_enum_variable_reference_variant_assignment_target_identifier( + &mut self, + ast: &'alloc AssignmentTargetIdentifier, + ) { + } + + fn visit_binding_pattern(&mut self, ast: &'alloc BindingPattern<'alloc>) { + self.enter_binding_pattern(ast); + match ast { + BindingPattern::ObjectBinding(ast) => { + self.visit_enum_binding_pattern_variant_object_binding(ast) + } + BindingPattern::ArrayBinding(ast) => { + self.visit_enum_binding_pattern_variant_array_binding(ast) + } + } + self.leave_binding_pattern(ast); + } + + fn enter_binding_pattern(&mut self, ast: &'alloc BindingPattern<'alloc>) { + } + + fn leave_binding_pattern(&mut self, ast: &'alloc BindingPattern<'alloc>) { + } + + fn visit_enum_binding_pattern_variant_object_binding( + &mut self, + ast: &'alloc ObjectBinding<'alloc>, + ) { + self.enter_enum_binding_pattern_variant_object_binding(ast); + self.visit_object_binding(ast); + self.leave_enum_binding_pattern_variant_object_binding(ast); + } + + fn enter_enum_binding_pattern_variant_object_binding( + &mut self, + ast: &'alloc ObjectBinding<'alloc>, + ) { + } + + fn leave_enum_binding_pattern_variant_object_binding( + &mut self, + ast: &'alloc ObjectBinding<'alloc>, + ) { + } + + fn visit_enum_binding_pattern_variant_array_binding( + &mut self, + ast: &'alloc ArrayBinding<'alloc>, + ) { + self.enter_enum_binding_pattern_variant_array_binding(ast); + self.visit_array_binding(ast); + self.leave_enum_binding_pattern_variant_array_binding(ast); + } + + fn enter_enum_binding_pattern_variant_array_binding( + &mut self, + ast: &'alloc ArrayBinding<'alloc>, + ) { + } + + fn leave_enum_binding_pattern_variant_array_binding( + &mut self, + ast: &'alloc ArrayBinding<'alloc>, + ) { + } + + fn visit_binding(&mut self, ast: &'alloc Binding<'alloc>) { + self.enter_binding(ast); + match ast { + Binding::BindingPattern(ast) => { + self.visit_enum_binding_variant_binding_pattern(ast) + } + Binding::BindingIdentifier(ast) => { + self.visit_enum_binding_variant_binding_identifier(ast) + } + } + self.leave_binding(ast); + } + + fn enter_binding(&mut self, ast: &'alloc Binding<'alloc>) { + } + + fn leave_binding(&mut self, ast: &'alloc Binding<'alloc>) { + } + + fn visit_enum_binding_variant_binding_pattern( + &mut self, + ast: &'alloc BindingPattern<'alloc>, + ) { + self.enter_enum_binding_variant_binding_pattern(ast); + self.visit_binding_pattern(ast); + self.leave_enum_binding_variant_binding_pattern(ast); + } + + fn enter_enum_binding_variant_binding_pattern( + &mut self, + ast: &'alloc BindingPattern<'alloc>, + ) { + } + + fn leave_enum_binding_variant_binding_pattern( + &mut self, + ast: &'alloc BindingPattern<'alloc>, + ) { + } + + fn visit_enum_binding_variant_binding_identifier( + &mut self, + ast: &'alloc BindingIdentifier, + ) { + self.enter_enum_binding_variant_binding_identifier(ast); + self.visit_binding_identifier(ast); + self.leave_enum_binding_variant_binding_identifier(ast); + } + + fn enter_enum_binding_variant_binding_identifier( + &mut self, + ast: &'alloc BindingIdentifier, + ) { + } + + fn leave_enum_binding_variant_binding_identifier( + &mut self, + ast: &'alloc BindingIdentifier, + ) { + } + + fn visit_simple_assignment_target(&mut self, ast: &'alloc SimpleAssignmentTarget<'alloc>) { + self.enter_simple_assignment_target(ast); + match ast { + SimpleAssignmentTarget::AssignmentTargetIdentifier(ast) => { + self.visit_enum_simple_assignment_target_variant_assignment_target_identifier(ast) + } + SimpleAssignmentTarget::MemberAssignmentTarget(ast) => { + self.visit_enum_simple_assignment_target_variant_member_assignment_target(ast) + } + } + self.leave_simple_assignment_target(ast); + } + + fn enter_simple_assignment_target(&mut self, ast: &'alloc SimpleAssignmentTarget<'alloc>) { + } + + fn leave_simple_assignment_target(&mut self, ast: &'alloc SimpleAssignmentTarget<'alloc>) { + } + + fn visit_enum_simple_assignment_target_variant_assignment_target_identifier( + &mut self, + ast: &'alloc AssignmentTargetIdentifier, + ) { + self.enter_enum_simple_assignment_target_variant_assignment_target_identifier(ast); + self.visit_assignment_target_identifier(ast); + self.leave_enum_simple_assignment_target_variant_assignment_target_identifier(ast); + } + + fn enter_enum_simple_assignment_target_variant_assignment_target_identifier( + &mut self, + ast: &'alloc AssignmentTargetIdentifier, + ) { + } + + fn leave_enum_simple_assignment_target_variant_assignment_target_identifier( + &mut self, + ast: &'alloc AssignmentTargetIdentifier, + ) { + } + + fn visit_enum_simple_assignment_target_variant_member_assignment_target( + &mut self, + ast: &'alloc MemberAssignmentTarget<'alloc>, + ) { + self.enter_enum_simple_assignment_target_variant_member_assignment_target(ast); + self.visit_member_assignment_target(ast); + self.leave_enum_simple_assignment_target_variant_member_assignment_target(ast); + } + + fn enter_enum_simple_assignment_target_variant_member_assignment_target( + &mut self, + ast: &'alloc MemberAssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_simple_assignment_target_variant_member_assignment_target( + &mut self, + ast: &'alloc MemberAssignmentTarget<'alloc>, + ) { + } + + fn visit_assignment_target_pattern(&mut self, ast: &'alloc AssignmentTargetPattern<'alloc>) { + self.enter_assignment_target_pattern(ast); + match ast { + AssignmentTargetPattern::ArrayAssignmentTarget(ast) => { + self.visit_enum_assignment_target_pattern_variant_array_assignment_target(ast) + } + AssignmentTargetPattern::ObjectAssignmentTarget(ast) => { + self.visit_enum_assignment_target_pattern_variant_object_assignment_target(ast) + } + } + self.leave_assignment_target_pattern(ast); + } + + fn enter_assignment_target_pattern(&mut self, ast: &'alloc AssignmentTargetPattern<'alloc>) { + } + + fn leave_assignment_target_pattern(&mut self, ast: &'alloc AssignmentTargetPattern<'alloc>) { + } + + fn visit_enum_assignment_target_pattern_variant_array_assignment_target( + &mut self, + ast: &'alloc ArrayAssignmentTarget<'alloc>, + ) { + self.enter_enum_assignment_target_pattern_variant_array_assignment_target(ast); + self.visit_array_assignment_target(ast); + self.leave_enum_assignment_target_pattern_variant_array_assignment_target(ast); + } + + fn enter_enum_assignment_target_pattern_variant_array_assignment_target( + &mut self, + ast: &'alloc ArrayAssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_assignment_target_pattern_variant_array_assignment_target( + &mut self, + ast: &'alloc ArrayAssignmentTarget<'alloc>, + ) { + } + + fn visit_enum_assignment_target_pattern_variant_object_assignment_target( + &mut self, + ast: &'alloc ObjectAssignmentTarget<'alloc>, + ) { + self.enter_enum_assignment_target_pattern_variant_object_assignment_target(ast); + self.visit_object_assignment_target(ast); + self.leave_enum_assignment_target_pattern_variant_object_assignment_target(ast); + } + + fn enter_enum_assignment_target_pattern_variant_object_assignment_target( + &mut self, + ast: &'alloc ObjectAssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_assignment_target_pattern_variant_object_assignment_target( + &mut self, + ast: &'alloc ObjectAssignmentTarget<'alloc>, + ) { + } + + fn visit_assignment_target(&mut self, ast: &'alloc AssignmentTarget<'alloc>) { + self.enter_assignment_target(ast); + match ast { + AssignmentTarget::AssignmentTargetPattern(ast) => { + self.visit_enum_assignment_target_variant_assignment_target_pattern(ast) + } + AssignmentTarget::SimpleAssignmentTarget(ast) => { + self.visit_enum_assignment_target_variant_simple_assignment_target(ast) + } + } + self.leave_assignment_target(ast); + } + + fn enter_assignment_target(&mut self, ast: &'alloc AssignmentTarget<'alloc>) { + } + + fn leave_assignment_target(&mut self, ast: &'alloc AssignmentTarget<'alloc>) { + } + + fn visit_enum_assignment_target_variant_assignment_target_pattern( + &mut self, + ast: &'alloc AssignmentTargetPattern<'alloc>, + ) { + self.enter_enum_assignment_target_variant_assignment_target_pattern(ast); + self.visit_assignment_target_pattern(ast); + self.leave_enum_assignment_target_variant_assignment_target_pattern(ast); + } + + fn enter_enum_assignment_target_variant_assignment_target_pattern( + &mut self, + ast: &'alloc AssignmentTargetPattern<'alloc>, + ) { + } + + fn leave_enum_assignment_target_variant_assignment_target_pattern( + &mut self, + ast: &'alloc AssignmentTargetPattern<'alloc>, + ) { + } + + fn visit_enum_assignment_target_variant_simple_assignment_target( + &mut self, + ast: &'alloc SimpleAssignmentTarget<'alloc>, + ) { + self.enter_enum_assignment_target_variant_simple_assignment_target(ast); + self.visit_simple_assignment_target(ast); + self.leave_enum_assignment_target_variant_simple_assignment_target(ast); + } + + fn enter_enum_assignment_target_variant_simple_assignment_target( + &mut self, + ast: &'alloc SimpleAssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_assignment_target_variant_simple_assignment_target( + &mut self, + ast: &'alloc SimpleAssignmentTarget<'alloc>, + ) { + } + + fn visit_parameter(&mut self, ast: &'alloc Parameter<'alloc>) { + self.enter_parameter(ast); + match ast { + Parameter::Binding(ast) => { + self.visit_enum_parameter_variant_binding(ast) + } + Parameter::BindingWithDefault(ast) => { + self.visit_enum_parameter_variant_binding_with_default(ast) + } + } + self.leave_parameter(ast); + } + + fn enter_parameter(&mut self, ast: &'alloc Parameter<'alloc>) { + } + + fn leave_parameter(&mut self, ast: &'alloc Parameter<'alloc>) { + } + + fn visit_enum_parameter_variant_binding( + &mut self, + ast: &'alloc Binding<'alloc>, + ) { + self.enter_enum_parameter_variant_binding(ast); + self.visit_binding(ast); + self.leave_enum_parameter_variant_binding(ast); + } + + fn enter_enum_parameter_variant_binding( + &mut self, + ast: &'alloc Binding<'alloc>, + ) { + } + + fn leave_enum_parameter_variant_binding( + &mut self, + ast: &'alloc Binding<'alloc>, + ) { + } + + fn visit_enum_parameter_variant_binding_with_default( + &mut self, + ast: &'alloc BindingWithDefault<'alloc>, + ) { + self.enter_enum_parameter_variant_binding_with_default(ast); + self.visit_binding_with_default(ast); + self.leave_enum_parameter_variant_binding_with_default(ast); + } + + fn enter_enum_parameter_variant_binding_with_default( + &mut self, + ast: &'alloc BindingWithDefault<'alloc>, + ) { + } + + fn leave_enum_parameter_variant_binding_with_default( + &mut self, + ast: &'alloc BindingWithDefault<'alloc>, + ) { + } + + fn visit_binding_with_default(&mut self, ast: &'alloc BindingWithDefault<'alloc>) { + self.enter_binding_with_default(ast); + self.visit_binding(&ast.binding); + self.visit_expression(&ast.init); + self.leave_binding_with_default(ast); + } + + fn enter_binding_with_default(&mut self, ast: &'alloc BindingWithDefault<'alloc>) { + } + + fn leave_binding_with_default(&mut self, ast: &'alloc BindingWithDefault<'alloc>) { + } + + fn visit_binding_identifier(&mut self, ast: &'alloc BindingIdentifier) { + self.enter_binding_identifier(ast); + self.visit_identifier(&ast.name); + self.leave_binding_identifier(ast); + } + + fn enter_binding_identifier(&mut self, ast: &'alloc BindingIdentifier) { + } + + fn leave_binding_identifier(&mut self, ast: &'alloc BindingIdentifier) { + } + + fn visit_assignment_target_identifier(&mut self, ast: &'alloc AssignmentTargetIdentifier) { + self.enter_assignment_target_identifier(ast); + self.visit_identifier(&ast.name); + self.leave_assignment_target_identifier(ast); + } + + fn enter_assignment_target_identifier(&mut self, ast: &'alloc AssignmentTargetIdentifier) { + } + + fn leave_assignment_target_identifier(&mut self, ast: &'alloc AssignmentTargetIdentifier) { + } + + fn visit_expression_or_super(&mut self, ast: &'alloc ExpressionOrSuper<'alloc>) { + self.enter_expression_or_super(ast); + match ast { + ExpressionOrSuper::Expression(ast) => { + self.visit_enum_expression_or_super_variant_expression(ast) + } + ExpressionOrSuper::Super { .. } => { + self.visit_enum_expression_or_super_variant_super() + } + } + self.leave_expression_or_super(ast); + } + + fn enter_expression_or_super(&mut self, ast: &'alloc ExpressionOrSuper<'alloc>) { + } + + fn leave_expression_or_super(&mut self, ast: &'alloc ExpressionOrSuper<'alloc>) { + } + + fn visit_enum_expression_or_super_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_expression_or_super_variant_expression(ast); + self.visit_expression(ast); + self.leave_enum_expression_or_super_variant_expression(ast); + } + + fn enter_enum_expression_or_super_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_expression_or_super_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_expression_or_super_variant_super(&mut self) { + } + + fn visit_member_assignment_target(&mut self, ast: &'alloc MemberAssignmentTarget<'alloc>) { + self.enter_member_assignment_target(ast); + match ast { + MemberAssignmentTarget::ComputedMemberAssignmentTarget(ast) => { + self.visit_enum_member_assignment_target_variant_computed_member_assignment_target(ast) + } + MemberAssignmentTarget::PrivateFieldAssignmentTarget(ast) => { + self.visit_enum_member_assignment_target_variant_private_field_assignment_target(ast) + } + MemberAssignmentTarget::StaticMemberAssignmentTarget(ast) => { + self.visit_enum_member_assignment_target_variant_static_member_assignment_target(ast) + } + } + self.leave_member_assignment_target(ast); + } + + fn enter_member_assignment_target(&mut self, ast: &'alloc MemberAssignmentTarget<'alloc>) { + } + + fn leave_member_assignment_target(&mut self, ast: &'alloc MemberAssignmentTarget<'alloc>) { + } + + fn visit_enum_member_assignment_target_variant_computed_member_assignment_target( + &mut self, + ast: &'alloc ComputedMemberAssignmentTarget<'alloc>, + ) { + self.enter_enum_member_assignment_target_variant_computed_member_assignment_target(ast); + self.visit_computed_member_assignment_target(ast); + self.leave_enum_member_assignment_target_variant_computed_member_assignment_target(ast); + } + + fn enter_enum_member_assignment_target_variant_computed_member_assignment_target( + &mut self, + ast: &'alloc ComputedMemberAssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_member_assignment_target_variant_computed_member_assignment_target( + &mut self, + ast: &'alloc ComputedMemberAssignmentTarget<'alloc>, + ) { + } + + fn visit_enum_member_assignment_target_variant_private_field_assignment_target( + &mut self, + ast: &'alloc PrivateFieldAssignmentTarget<'alloc>, + ) { + self.enter_enum_member_assignment_target_variant_private_field_assignment_target(ast); + self.visit_private_field_assignment_target(ast); + self.leave_enum_member_assignment_target_variant_private_field_assignment_target(ast); + } + + fn enter_enum_member_assignment_target_variant_private_field_assignment_target( + &mut self, + ast: &'alloc PrivateFieldAssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_member_assignment_target_variant_private_field_assignment_target( + &mut self, + ast: &'alloc PrivateFieldAssignmentTarget<'alloc>, + ) { + } + + fn visit_enum_member_assignment_target_variant_static_member_assignment_target( + &mut self, + ast: &'alloc StaticMemberAssignmentTarget<'alloc>, + ) { + self.enter_enum_member_assignment_target_variant_static_member_assignment_target(ast); + self.visit_static_member_assignment_target(ast); + self.leave_enum_member_assignment_target_variant_static_member_assignment_target(ast); + } + + fn enter_enum_member_assignment_target_variant_static_member_assignment_target( + &mut self, + ast: &'alloc StaticMemberAssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_member_assignment_target_variant_static_member_assignment_target( + &mut self, + ast: &'alloc StaticMemberAssignmentTarget<'alloc>, + ) { + } + + fn visit_computed_member_assignment_target(&mut self, ast: &'alloc ComputedMemberAssignmentTarget<'alloc>) { + self.enter_computed_member_assignment_target(ast); + self.visit_expression_or_super(&ast.object); + self.visit_expression(&ast.expression); + self.leave_computed_member_assignment_target(ast); + } + + fn enter_computed_member_assignment_target(&mut self, ast: &'alloc ComputedMemberAssignmentTarget<'alloc>) { + } + + fn leave_computed_member_assignment_target(&mut self, ast: &'alloc ComputedMemberAssignmentTarget<'alloc>) { + } + + fn visit_private_field_assignment_target(&mut self, ast: &'alloc PrivateFieldAssignmentTarget<'alloc>) { + self.enter_private_field_assignment_target(ast); + self.visit_expression_or_super(&ast.object); + self.visit_private_identifier(&ast.field); + self.leave_private_field_assignment_target(ast); + } + + fn enter_private_field_assignment_target(&mut self, ast: &'alloc PrivateFieldAssignmentTarget<'alloc>) { + } + + fn leave_private_field_assignment_target(&mut self, ast: &'alloc PrivateFieldAssignmentTarget<'alloc>) { + } + + fn visit_static_member_assignment_target(&mut self, ast: &'alloc StaticMemberAssignmentTarget<'alloc>) { + self.enter_static_member_assignment_target(ast); + self.visit_expression_or_super(&ast.object); + self.visit_identifier_name(&ast.property); + self.leave_static_member_assignment_target(ast); + } + + fn enter_static_member_assignment_target(&mut self, ast: &'alloc StaticMemberAssignmentTarget<'alloc>) { + } + + fn leave_static_member_assignment_target(&mut self, ast: &'alloc StaticMemberAssignmentTarget<'alloc>) { + } + + fn visit_array_binding(&mut self, ast: &'alloc ArrayBinding<'alloc>) { + self.enter_array_binding(ast); + for item in &ast.elements { + if let Some(item) = item { + self.visit_parameter(item); + } + } + if let Some(item) = &ast.rest { + self.visit_binding(item); + } + self.leave_array_binding(ast); + } + + fn enter_array_binding(&mut self, ast: &'alloc ArrayBinding<'alloc>) { + } + + fn leave_array_binding(&mut self, ast: &'alloc ArrayBinding<'alloc>) { + } + + fn visit_object_binding(&mut self, ast: &'alloc ObjectBinding<'alloc>) { + self.enter_object_binding(ast); + for item in &ast.properties { + self.visit_binding_property(item); + } + if let Some(item) = &ast.rest { + self.visit_binding_identifier(item); + } + self.leave_object_binding(ast); + } + + fn enter_object_binding(&mut self, ast: &'alloc ObjectBinding<'alloc>) { + } + + fn leave_object_binding(&mut self, ast: &'alloc ObjectBinding<'alloc>) { + } + + fn visit_binding_property(&mut self, ast: &'alloc BindingProperty<'alloc>) { + self.enter_binding_property(ast); + match ast { + BindingProperty::BindingPropertyIdentifier(ast) => { + self.visit_enum_binding_property_variant_binding_property_identifier(ast) + } + BindingProperty::BindingPropertyProperty(ast) => { + self.visit_enum_binding_property_variant_binding_property_property(ast) + } + } + self.leave_binding_property(ast); + } + + fn enter_binding_property(&mut self, ast: &'alloc BindingProperty<'alloc>) { + } + + fn leave_binding_property(&mut self, ast: &'alloc BindingProperty<'alloc>) { + } + + fn visit_enum_binding_property_variant_binding_property_identifier( + &mut self, + ast: &'alloc BindingPropertyIdentifier<'alloc>, + ) { + self.enter_enum_binding_property_variant_binding_property_identifier(ast); + self.visit_binding_property_identifier(ast); + self.leave_enum_binding_property_variant_binding_property_identifier(ast); + } + + fn enter_enum_binding_property_variant_binding_property_identifier( + &mut self, + ast: &'alloc BindingPropertyIdentifier<'alloc>, + ) { + } + + fn leave_enum_binding_property_variant_binding_property_identifier( + &mut self, + ast: &'alloc BindingPropertyIdentifier<'alloc>, + ) { + } + + fn visit_enum_binding_property_variant_binding_property_property( + &mut self, + ast: &'alloc BindingPropertyProperty<'alloc>, + ) { + self.enter_enum_binding_property_variant_binding_property_property(ast); + self.visit_binding_property_property(ast); + self.leave_enum_binding_property_variant_binding_property_property(ast); + } + + fn enter_enum_binding_property_variant_binding_property_property( + &mut self, + ast: &'alloc BindingPropertyProperty<'alloc>, + ) { + } + + fn leave_enum_binding_property_variant_binding_property_property( + &mut self, + ast: &'alloc BindingPropertyProperty<'alloc>, + ) { + } + + fn visit_binding_property_identifier(&mut self, ast: &'alloc BindingPropertyIdentifier<'alloc>) { + self.enter_binding_property_identifier(ast); + self.visit_binding_identifier(&ast.binding); + if let Some(item) = &ast.init { + self.visit_expression(item); + } + self.leave_binding_property_identifier(ast); + } + + fn enter_binding_property_identifier(&mut self, ast: &'alloc BindingPropertyIdentifier<'alloc>) { + } + + fn leave_binding_property_identifier(&mut self, ast: &'alloc BindingPropertyIdentifier<'alloc>) { + } + + fn visit_binding_property_property(&mut self, ast: &'alloc BindingPropertyProperty<'alloc>) { + self.enter_binding_property_property(ast); + self.visit_property_name(&ast.name); + self.visit_parameter(&ast.binding); + self.leave_binding_property_property(ast); + } + + fn enter_binding_property_property(&mut self, ast: &'alloc BindingPropertyProperty<'alloc>) { + } + + fn leave_binding_property_property(&mut self, ast: &'alloc BindingPropertyProperty<'alloc>) { + } + + fn visit_assignment_target_with_default(&mut self, ast: &'alloc AssignmentTargetWithDefault<'alloc>) { + self.enter_assignment_target_with_default(ast); + self.visit_assignment_target(&ast.binding); + self.visit_expression(&ast.init); + self.leave_assignment_target_with_default(ast); + } + + fn enter_assignment_target_with_default(&mut self, ast: &'alloc AssignmentTargetWithDefault<'alloc>) { + } + + fn leave_assignment_target_with_default(&mut self, ast: &'alloc AssignmentTargetWithDefault<'alloc>) { + } + + fn visit_assignment_target_maybe_default(&mut self, ast: &'alloc AssignmentTargetMaybeDefault<'alloc>) { + self.enter_assignment_target_maybe_default(ast); + match ast { + AssignmentTargetMaybeDefault::AssignmentTarget(ast) => { + self.visit_enum_assignment_target_maybe_default_variant_assignment_target(ast) + } + AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(ast) => { + self.visit_enum_assignment_target_maybe_default_variant_assignment_target_with_default(ast) + } + } + self.leave_assignment_target_maybe_default(ast); + } + + fn enter_assignment_target_maybe_default(&mut self, ast: &'alloc AssignmentTargetMaybeDefault<'alloc>) { + } + + fn leave_assignment_target_maybe_default(&mut self, ast: &'alloc AssignmentTargetMaybeDefault<'alloc>) { + } + + fn visit_enum_assignment_target_maybe_default_variant_assignment_target( + &mut self, + ast: &'alloc AssignmentTarget<'alloc>, + ) { + self.enter_enum_assignment_target_maybe_default_variant_assignment_target(ast); + self.visit_assignment_target(ast); + self.leave_enum_assignment_target_maybe_default_variant_assignment_target(ast); + } + + fn enter_enum_assignment_target_maybe_default_variant_assignment_target( + &mut self, + ast: &'alloc AssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_assignment_target_maybe_default_variant_assignment_target( + &mut self, + ast: &'alloc AssignmentTarget<'alloc>, + ) { + } + + fn visit_enum_assignment_target_maybe_default_variant_assignment_target_with_default( + &mut self, + ast: &'alloc AssignmentTargetWithDefault<'alloc>, + ) { + self.enter_enum_assignment_target_maybe_default_variant_assignment_target_with_default(ast); + self.visit_assignment_target_with_default(ast); + self.leave_enum_assignment_target_maybe_default_variant_assignment_target_with_default(ast); + } + + fn enter_enum_assignment_target_maybe_default_variant_assignment_target_with_default( + &mut self, + ast: &'alloc AssignmentTargetWithDefault<'alloc>, + ) { + } + + fn leave_enum_assignment_target_maybe_default_variant_assignment_target_with_default( + &mut self, + ast: &'alloc AssignmentTargetWithDefault<'alloc>, + ) { + } + + fn visit_array_assignment_target(&mut self, ast: &'alloc ArrayAssignmentTarget<'alloc>) { + self.enter_array_assignment_target(ast); + for item in &ast.elements { + if let Some(item) = item { + self.visit_assignment_target_maybe_default(item); + } + } + if let Some(item) = &ast.rest { + self.visit_assignment_target(item); + } + self.leave_array_assignment_target(ast); + } + + fn enter_array_assignment_target(&mut self, ast: &'alloc ArrayAssignmentTarget<'alloc>) { + } + + fn leave_array_assignment_target(&mut self, ast: &'alloc ArrayAssignmentTarget<'alloc>) { + } + + fn visit_object_assignment_target(&mut self, ast: &'alloc ObjectAssignmentTarget<'alloc>) { + self.enter_object_assignment_target(ast); + for item in &ast.properties { + self.visit_assignment_target_property(item); + } + if let Some(item) = &ast.rest { + self.visit_assignment_target(item); + } + self.leave_object_assignment_target(ast); + } + + fn enter_object_assignment_target(&mut self, ast: &'alloc ObjectAssignmentTarget<'alloc>) { + } + + fn leave_object_assignment_target(&mut self, ast: &'alloc ObjectAssignmentTarget<'alloc>) { + } + + fn visit_assignment_target_property(&mut self, ast: &'alloc AssignmentTargetProperty<'alloc>) { + self.enter_assignment_target_property(ast); + match ast { + AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(ast) => { + self.visit_enum_assignment_target_property_variant_assignment_target_property_identifier(ast) + } + AssignmentTargetProperty::AssignmentTargetPropertyProperty(ast) => { + self.visit_enum_assignment_target_property_variant_assignment_target_property_property(ast) + } + } + self.leave_assignment_target_property(ast); + } + + fn enter_assignment_target_property(&mut self, ast: &'alloc AssignmentTargetProperty<'alloc>) { + } + + fn leave_assignment_target_property(&mut self, ast: &'alloc AssignmentTargetProperty<'alloc>) { + } + + fn visit_enum_assignment_target_property_variant_assignment_target_property_identifier( + &mut self, + ast: &'alloc AssignmentTargetPropertyIdentifier<'alloc>, + ) { + self.enter_enum_assignment_target_property_variant_assignment_target_property_identifier(ast); + self.visit_assignment_target_property_identifier(ast); + self.leave_enum_assignment_target_property_variant_assignment_target_property_identifier(ast); + } + + fn enter_enum_assignment_target_property_variant_assignment_target_property_identifier( + &mut self, + ast: &'alloc AssignmentTargetPropertyIdentifier<'alloc>, + ) { + } + + fn leave_enum_assignment_target_property_variant_assignment_target_property_identifier( + &mut self, + ast: &'alloc AssignmentTargetPropertyIdentifier<'alloc>, + ) { + } + + fn visit_enum_assignment_target_property_variant_assignment_target_property_property( + &mut self, + ast: &'alloc AssignmentTargetPropertyProperty<'alloc>, + ) { + self.enter_enum_assignment_target_property_variant_assignment_target_property_property(ast); + self.visit_assignment_target_property_property(ast); + self.leave_enum_assignment_target_property_variant_assignment_target_property_property(ast); + } + + fn enter_enum_assignment_target_property_variant_assignment_target_property_property( + &mut self, + ast: &'alloc AssignmentTargetPropertyProperty<'alloc>, + ) { + } + + fn leave_enum_assignment_target_property_variant_assignment_target_property_property( + &mut self, + ast: &'alloc AssignmentTargetPropertyProperty<'alloc>, + ) { + } + + fn visit_assignment_target_property_identifier(&mut self, ast: &'alloc AssignmentTargetPropertyIdentifier<'alloc>) { + self.enter_assignment_target_property_identifier(ast); + self.visit_assignment_target_identifier(&ast.binding); + if let Some(item) = &ast.init { + self.visit_expression(item); + } + self.leave_assignment_target_property_identifier(ast); + } + + fn enter_assignment_target_property_identifier(&mut self, ast: &'alloc AssignmentTargetPropertyIdentifier<'alloc>) { + } + + fn leave_assignment_target_property_identifier(&mut self, ast: &'alloc AssignmentTargetPropertyIdentifier<'alloc>) { + } + + fn visit_assignment_target_property_property(&mut self, ast: &'alloc AssignmentTargetPropertyProperty<'alloc>) { + self.enter_assignment_target_property_property(ast); + self.visit_property_name(&ast.name); + self.visit_assignment_target_maybe_default(&ast.binding); + self.leave_assignment_target_property_property(ast); + } + + fn enter_assignment_target_property_property(&mut self, ast: &'alloc AssignmentTargetPropertyProperty<'alloc>) { + } + + fn leave_assignment_target_property_property(&mut self, ast: &'alloc AssignmentTargetPropertyProperty<'alloc>) { + } + + fn visit_class_expression(&mut self, ast: &'alloc ClassExpression<'alloc>) { + self.enter_class_expression(ast); + if let Some(item) = &ast.name { + self.visit_binding_identifier(item); + } + if let Some(item) = &ast.super_ { + self.visit_expression(item); + } + for item in &ast.elements { + self.visit_class_element(item); + } + self.leave_class_expression(ast); + } + + fn enter_class_expression(&mut self, ast: &'alloc ClassExpression<'alloc>) { + } + + fn leave_class_expression(&mut self, ast: &'alloc ClassExpression<'alloc>) { + } + + fn visit_class_declaration(&mut self, ast: &'alloc ClassDeclaration<'alloc>) { + self.enter_class_declaration(ast); + self.visit_binding_identifier(&ast.name); + if let Some(item) = &ast.super_ { + self.visit_expression(item); + } + for item in &ast.elements { + self.visit_class_element(item); + } + self.leave_class_declaration(ast); + } + + fn enter_class_declaration(&mut self, ast: &'alloc ClassDeclaration<'alloc>) { + } + + fn leave_class_declaration(&mut self, ast: &'alloc ClassDeclaration<'alloc>) { + } + + fn visit_class_element(&mut self, ast: &'alloc ClassElement<'alloc>) { + self.enter_class_element(ast); + match ast { + ClassElement::MethodDefinition { is_static, method, .. } => { + self.visit_enum_class_element_variant_method_definition( + is_static, + method, + ) + } + ClassElement::FieldDefinition { name, init, .. } => { + self.visit_enum_class_element_variant_field_definition( + name, + init, + ) + } + } + self.leave_class_element(ast); + } + + fn enter_class_element(&mut self, ast: &'alloc ClassElement<'alloc>) { + } + + fn leave_class_element(&mut self, ast: &'alloc ClassElement<'alloc>) { + } + + fn visit_enum_class_element_variant_method_definition( + &mut self, + is_static: &'alloc bool, + method: &'alloc MethodDefinition<'alloc>, + ) { + self.enter_enum_class_element_variant_method_definition( + is_static, + method, + ); + self.visit_method_definition(method); + self.leave_enum_class_element_variant_method_definition( + is_static, + method, + ); + } + + fn enter_enum_class_element_variant_method_definition( + &mut self, + is_static: &'alloc bool, + method: &'alloc MethodDefinition<'alloc>, + ) { + } + + fn leave_enum_class_element_variant_method_definition( + &mut self, + is_static: &'alloc bool, + method: &'alloc MethodDefinition<'alloc>, + ) { + } + + fn visit_enum_class_element_variant_field_definition( + &mut self, + name: &'alloc ClassElementName<'alloc>, + init: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + ) { + self.enter_enum_class_element_variant_field_definition( + name, + init, + ); + self.visit_class_element_name(name); + if let Some(item) = init { + self.visit_expression(item); + } + self.leave_enum_class_element_variant_field_definition( + name, + init, + ); + } + + fn enter_enum_class_element_variant_field_definition( + &mut self, + name: &'alloc ClassElementName<'alloc>, + init: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + ) { + } + + fn leave_enum_class_element_variant_field_definition( + &mut self, + name: &'alloc ClassElementName<'alloc>, + init: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>, + ) { + } + + fn visit_module_items(&mut self, ast: &'alloc ModuleItems<'alloc>) { + self.enter_module_items(ast); + match ast { + ModuleItems::ImportDeclaration(ast) => { + self.visit_enum_module_items_variant_import_declaration(ast) + } + ModuleItems::ExportDeclaration(ast) => { + self.visit_enum_module_items_variant_export_declaration(ast) + } + ModuleItems::Statement(ast) => { + self.visit_enum_module_items_variant_statement(ast) + } + } + self.leave_module_items(ast); + } + + fn enter_module_items(&mut self, ast: &'alloc ModuleItems<'alloc>) { + } + + fn leave_module_items(&mut self, ast: &'alloc ModuleItems<'alloc>) { + } + + fn visit_enum_module_items_variant_import_declaration( + &mut self, + ast: &'alloc ImportDeclaration<'alloc>, + ) { + self.enter_enum_module_items_variant_import_declaration(ast); + self.visit_import_declaration(ast); + self.leave_enum_module_items_variant_import_declaration(ast); + } + + fn enter_enum_module_items_variant_import_declaration( + &mut self, + ast: &'alloc ImportDeclaration<'alloc>, + ) { + } + + fn leave_enum_module_items_variant_import_declaration( + &mut self, + ast: &'alloc ImportDeclaration<'alloc>, + ) { + } + + fn visit_enum_module_items_variant_export_declaration( + &mut self, + ast: &'alloc ExportDeclaration<'alloc>, + ) { + self.enter_enum_module_items_variant_export_declaration(ast); + self.visit_export_declaration(ast); + self.leave_enum_module_items_variant_export_declaration(ast); + } + + fn enter_enum_module_items_variant_export_declaration( + &mut self, + ast: &'alloc ExportDeclaration<'alloc>, + ) { + } + + fn leave_enum_module_items_variant_export_declaration( + &mut self, + ast: &'alloc ExportDeclaration<'alloc>, + ) { + } + + fn visit_enum_module_items_variant_statement( + &mut self, + ast: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + self.enter_enum_module_items_variant_statement(ast); + self.visit_statement(ast); + self.leave_enum_module_items_variant_statement(ast); + } + + fn enter_enum_module_items_variant_statement( + &mut self, + ast: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn leave_enum_module_items_variant_statement( + &mut self, + ast: &'alloc arena::Box<'alloc, Statement<'alloc>>, + ) { + } + + fn visit_module(&mut self, ast: &'alloc Module<'alloc>) { + self.enter_module(ast); + for item in &ast.directives { + self.visit_directive(item); + } + for item in &ast.items { + self.visit_module_items(item); + } + self.leave_module(ast); + } + + fn enter_module(&mut self, ast: &'alloc Module<'alloc>) { + } + + fn leave_module(&mut self, ast: &'alloc Module<'alloc>) { + } + + fn visit_import(&mut self, ast: &'alloc Import<'alloc>) { + self.enter_import(ast); + if let Some(item) = &ast.default_binding { + self.visit_binding_identifier(item); + } + for item in &ast.named_imports { + self.visit_import_specifier(item); + } + self.leave_import(ast); + } + + fn enter_import(&mut self, ast: &'alloc Import<'alloc>) { + } + + fn leave_import(&mut self, ast: &'alloc Import<'alloc>) { + } + + fn visit_import_namespace(&mut self, ast: &'alloc ImportNamespace) { + self.enter_import_namespace(ast); + if let Some(item) = &ast.default_binding { + self.visit_binding_identifier(item); + } + self.visit_binding_identifier(&ast.namespace_binding); + self.leave_import_namespace(ast); + } + + fn enter_import_namespace(&mut self, ast: &'alloc ImportNamespace) { + } + + fn leave_import_namespace(&mut self, ast: &'alloc ImportNamespace) { + } + + fn visit_import_specifier(&mut self, ast: &'alloc ImportSpecifier) { + self.enter_import_specifier(ast); + if let Some(item) = &ast.name { + self.visit_identifier_name(item); + } + self.visit_binding_identifier(&ast.binding); + self.leave_import_specifier(ast); + } + + fn enter_import_specifier(&mut self, ast: &'alloc ImportSpecifier) { + } + + fn leave_import_specifier(&mut self, ast: &'alloc ImportSpecifier) { + } + + fn visit_export_all_from(&mut self, ast: &'alloc ExportAllFrom) { + self.enter_export_all_from(ast); + self.leave_export_all_from(ast); + } + + fn enter_export_all_from(&mut self, ast: &'alloc ExportAllFrom) { + } + + fn leave_export_all_from(&mut self, ast: &'alloc ExportAllFrom) { + } + + fn visit_export_from(&mut self, ast: &'alloc ExportFrom<'alloc>) { + self.enter_export_from(ast); + for item in &ast.named_exports { + self.visit_export_from_specifier(item); + } + self.leave_export_from(ast); + } + + fn enter_export_from(&mut self, ast: &'alloc ExportFrom<'alloc>) { + } + + fn leave_export_from(&mut self, ast: &'alloc ExportFrom<'alloc>) { + } + + fn visit_export_locals(&mut self, ast: &'alloc ExportLocals<'alloc>) { + self.enter_export_locals(ast); + for item in &ast.named_exports { + self.visit_export_local_specifier(item); + } + self.leave_export_locals(ast); + } + + fn enter_export_locals(&mut self, ast: &'alloc ExportLocals<'alloc>) { + } + + fn leave_export_locals(&mut self, ast: &'alloc ExportLocals<'alloc>) { + } + + fn visit_export(&mut self, ast: &'alloc Export<'alloc>) { + self.enter_export(ast); + match ast { + Export::FunctionDeclaration(ast) => { + self.visit_enum_export_variant_function_declaration(ast) + } + Export::ClassDeclaration(ast) => { + self.visit_enum_export_variant_class_declaration(ast) + } + Export::VariableDeclaration(ast) => { + self.visit_enum_export_variant_variable_declaration(ast) + } + } + self.leave_export(ast); + } + + fn enter_export(&mut self, ast: &'alloc Export<'alloc>) { + } + + fn leave_export(&mut self, ast: &'alloc Export<'alloc>) { + } + + fn visit_enum_export_variant_function_declaration( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + self.enter_enum_export_variant_function_declaration(ast); + self.visit_function(ast); + self.leave_enum_export_variant_function_declaration(ast); + } + + fn enter_enum_export_variant_function_declaration( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + } + + fn leave_enum_export_variant_function_declaration( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + } + + fn visit_enum_export_variant_class_declaration( + &mut self, + ast: &'alloc ClassDeclaration<'alloc>, + ) { + self.enter_enum_export_variant_class_declaration(ast); + self.visit_class_declaration(ast); + self.leave_enum_export_variant_class_declaration(ast); + } + + fn enter_enum_export_variant_class_declaration( + &mut self, + ast: &'alloc ClassDeclaration<'alloc>, + ) { + } + + fn leave_enum_export_variant_class_declaration( + &mut self, + ast: &'alloc ClassDeclaration<'alloc>, + ) { + } + + fn visit_enum_export_variant_variable_declaration( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + self.enter_enum_export_variant_variable_declaration(ast); + self.visit_variable_declaration(ast); + self.leave_enum_export_variant_variable_declaration(ast); + } + + fn enter_enum_export_variant_variable_declaration( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + } + + fn leave_enum_export_variant_variable_declaration( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + } + + fn visit_export_default(&mut self, ast: &'alloc ExportDefault<'alloc>) { + self.enter_export_default(ast); + match ast { + ExportDefault::FunctionDeclaration(ast) => { + self.visit_enum_export_default_variant_function_declaration(ast) + } + ExportDefault::ClassDeclaration(ast) => { + self.visit_enum_export_default_variant_class_declaration(ast) + } + ExportDefault::Expression(ast) => { + self.visit_enum_export_default_variant_expression(ast) + } + } + self.leave_export_default(ast); + } + + fn enter_export_default(&mut self, ast: &'alloc ExportDefault<'alloc>) { + } + + fn leave_export_default(&mut self, ast: &'alloc ExportDefault<'alloc>) { + } + + fn visit_enum_export_default_variant_function_declaration( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + self.enter_enum_export_default_variant_function_declaration(ast); + self.visit_function(ast); + self.leave_enum_export_default_variant_function_declaration(ast); + } + + fn enter_enum_export_default_variant_function_declaration( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + } + + fn leave_enum_export_default_variant_function_declaration( + &mut self, + ast: &'alloc Function<'alloc>, + ) { + } + + fn visit_enum_export_default_variant_class_declaration( + &mut self, + ast: &'alloc ClassDeclaration<'alloc>, + ) { + self.enter_enum_export_default_variant_class_declaration(ast); + self.visit_class_declaration(ast); + self.leave_enum_export_default_variant_class_declaration(ast); + } + + fn enter_enum_export_default_variant_class_declaration( + &mut self, + ast: &'alloc ClassDeclaration<'alloc>, + ) { + } + + fn leave_enum_export_default_variant_class_declaration( + &mut self, + ast: &'alloc ClassDeclaration<'alloc>, + ) { + } + + fn visit_enum_export_default_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_export_default_variant_expression(ast); + self.visit_expression(ast); + self.leave_enum_export_default_variant_expression(ast); + } + + fn enter_enum_export_default_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_export_default_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_export_from_specifier(&mut self, ast: &'alloc ExportFromSpecifier) { + self.enter_export_from_specifier(ast); + self.visit_identifier_name(&ast.name); + if let Some(item) = &ast.exported_name { + self.visit_identifier_name(item); + } + self.leave_export_from_specifier(ast); + } + + fn enter_export_from_specifier(&mut self, ast: &'alloc ExportFromSpecifier) { + } + + fn leave_export_from_specifier(&mut self, ast: &'alloc ExportFromSpecifier) { + } + + fn visit_export_local_specifier(&mut self, ast: &'alloc ExportLocalSpecifier) { + self.enter_export_local_specifier(ast); + self.visit_identifier_expression(&ast.name); + if let Some(item) = &ast.exported_name { + self.visit_identifier_name(item); + } + self.leave_export_local_specifier(ast); + } + + fn enter_export_local_specifier(&mut self, ast: &'alloc ExportLocalSpecifier) { + } + + fn leave_export_local_specifier(&mut self, ast: &'alloc ExportLocalSpecifier) { + } + + fn visit_method(&mut self, ast: &'alloc Method<'alloc>) { + self.enter_method(ast); + self.visit_class_element_name(&ast.name); + self.visit_formal_parameters(&ast.params); + self.visit_function_body(&ast.body); + self.leave_method(ast); + } + + fn enter_method(&mut self, ast: &'alloc Method<'alloc>) { + } + + fn leave_method(&mut self, ast: &'alloc Method<'alloc>) { + } + + fn visit_getter(&mut self, ast: &'alloc Getter<'alloc>) { + self.enter_getter(ast); + self.visit_class_element_name(&ast.property_name); + self.visit_function_body(&ast.body); + self.leave_getter(ast); + } + + fn enter_getter(&mut self, ast: &'alloc Getter<'alloc>) { + } + + fn leave_getter(&mut self, ast: &'alloc Getter<'alloc>) { + } + + fn visit_setter(&mut self, ast: &'alloc Setter<'alloc>) { + self.enter_setter(ast); + self.visit_class_element_name(&ast.property_name); + self.visit_parameter(&ast.param); + self.visit_function_body(&ast.body); + self.leave_setter(ast); + } + + fn enter_setter(&mut self, ast: &'alloc Setter<'alloc>) { + } + + fn leave_setter(&mut self, ast: &'alloc Setter<'alloc>) { + } + + fn visit_data_property(&mut self, ast: &'alloc DataProperty<'alloc>) { + self.enter_data_property(ast); + self.visit_property_name(&ast.property_name); + self.visit_expression(&ast.expression); + self.leave_data_property(ast); + } + + fn enter_data_property(&mut self, ast: &'alloc DataProperty<'alloc>) { + } + + fn leave_data_property(&mut self, ast: &'alloc DataProperty<'alloc>) { + } + + fn visit_shorthand_property(&mut self, ast: &'alloc ShorthandProperty) { + self.enter_shorthand_property(ast); + self.visit_identifier_expression(&ast.name); + self.leave_shorthand_property(ast); + } + + fn enter_shorthand_property(&mut self, ast: &'alloc ShorthandProperty) { + } + + fn leave_shorthand_property(&mut self, ast: &'alloc ShorthandProperty) { + } + + fn visit_computed_property_name(&mut self, ast: &'alloc ComputedPropertyName<'alloc>) { + self.enter_computed_property_name(ast); + self.visit_expression(&ast.expression); + self.leave_computed_property_name(ast); + } + + fn enter_computed_property_name(&mut self, ast: &'alloc ComputedPropertyName<'alloc>) { + } + + fn leave_computed_property_name(&mut self, ast: &'alloc ComputedPropertyName<'alloc>) { + } + + fn visit_static_property_name(&mut self, ast: &'alloc StaticPropertyName) { + self.enter_static_property_name(ast); + self.leave_static_property_name(ast); + } + + fn enter_static_property_name(&mut self, ast: &'alloc StaticPropertyName) { + } + + fn leave_static_property_name(&mut self, ast: &'alloc StaticPropertyName) { + } + + fn visit_numeric_literal(&mut self, ast: &'alloc NumericLiteral) { + self.enter_numeric_literal(ast); + self.leave_numeric_literal(ast); + } + + fn enter_numeric_literal(&mut self, ast: &'alloc NumericLiteral) { + } + + fn leave_numeric_literal(&mut self, ast: &'alloc NumericLiteral) { + } + + fn visit_array_expression_element(&mut self, ast: &'alloc ArrayExpressionElement<'alloc>) { + self.enter_array_expression_element(ast); + match ast { + ArrayExpressionElement::SpreadElement(ast) => { + self.visit_enum_array_expression_element_variant_spread_element(ast) + } + ArrayExpressionElement::Expression(ast) => { + self.visit_enum_array_expression_element_variant_expression(ast) + } + ArrayExpressionElement::Elision { .. } => { + self.visit_enum_array_expression_element_variant_elision() + } + } + self.leave_array_expression_element(ast); + } + + fn enter_array_expression_element(&mut self, ast: &'alloc ArrayExpressionElement<'alloc>) { + } + + fn leave_array_expression_element(&mut self, ast: &'alloc ArrayExpressionElement<'alloc>) { + } + + fn visit_enum_array_expression_element_variant_spread_element( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_array_expression_element_variant_spread_element(ast); + self.visit_expression(ast); + self.leave_enum_array_expression_element_variant_spread_element(ast); + } + + fn enter_enum_array_expression_element_variant_spread_element( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_array_expression_element_variant_spread_element( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_array_expression_element_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_array_expression_element_variant_expression(ast); + self.visit_expression(ast); + self.leave_enum_array_expression_element_variant_expression(ast); + } + + fn enter_enum_array_expression_element_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_array_expression_element_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_array_expression_element_variant_elision(&mut self) { + } + + fn visit_array_expression(&mut self, ast: &'alloc ArrayExpression<'alloc>) { + self.enter_array_expression(ast); + for item in &ast.elements { + self.visit_array_expression_element(item); + } + self.leave_array_expression(ast); + } + + fn enter_array_expression(&mut self, ast: &'alloc ArrayExpression<'alloc>) { + } + + fn leave_array_expression(&mut self, ast: &'alloc ArrayExpression<'alloc>) { + } + + fn visit_arrow_expression_body(&mut self, ast: &'alloc ArrowExpressionBody<'alloc>) { + self.enter_arrow_expression_body(ast); + match ast { + ArrowExpressionBody::FunctionBody(ast) => { + self.visit_enum_arrow_expression_body_variant_function_body(ast) + } + ArrowExpressionBody::Expression(ast) => { + self.visit_enum_arrow_expression_body_variant_expression(ast) + } + } + self.leave_arrow_expression_body(ast); + } + + fn enter_arrow_expression_body(&mut self, ast: &'alloc ArrowExpressionBody<'alloc>) { + } + + fn leave_arrow_expression_body(&mut self, ast: &'alloc ArrowExpressionBody<'alloc>) { + } + + fn visit_enum_arrow_expression_body_variant_function_body( + &mut self, + ast: &'alloc FunctionBody<'alloc>, + ) { + self.enter_enum_arrow_expression_body_variant_function_body(ast); + self.visit_function_body(ast); + self.leave_enum_arrow_expression_body_variant_function_body(ast); + } + + fn enter_enum_arrow_expression_body_variant_function_body( + &mut self, + ast: &'alloc FunctionBody<'alloc>, + ) { + } + + fn leave_enum_arrow_expression_body_variant_function_body( + &mut self, + ast: &'alloc FunctionBody<'alloc>, + ) { + } + + fn visit_enum_arrow_expression_body_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_arrow_expression_body_variant_expression(ast); + self.visit_expression(ast); + self.leave_enum_arrow_expression_body_variant_expression(ast); + } + + fn enter_enum_arrow_expression_body_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_arrow_expression_body_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_computed_member_expression(&mut self, ast: &'alloc ComputedMemberExpression<'alloc>) { + self.enter_computed_member_expression(ast); + self.visit_expression_or_super(&ast.object); + self.visit_expression(&ast.expression); + self.leave_computed_member_expression(ast); + } + + fn enter_computed_member_expression(&mut self, ast: &'alloc ComputedMemberExpression<'alloc>) { + } + + fn leave_computed_member_expression(&mut self, ast: &'alloc ComputedMemberExpression<'alloc>) { + } + + fn visit_identifier_expression(&mut self, ast: &'alloc IdentifierExpression) { + self.enter_identifier_expression(ast); + self.visit_identifier(&ast.name); + self.leave_identifier_expression(ast); + } + + fn enter_identifier_expression(&mut self, ast: &'alloc IdentifierExpression) { + } + + fn leave_identifier_expression(&mut self, ast: &'alloc IdentifierExpression) { + } + + fn visit_object_expression(&mut self, ast: &'alloc ObjectExpression<'alloc>) { + self.enter_object_expression(ast); + for item in &ast.properties { + self.visit_object_property(item); + } + self.leave_object_expression(ast); + } + + fn enter_object_expression(&mut self, ast: &'alloc ObjectExpression<'alloc>) { + } + + fn leave_object_expression(&mut self, ast: &'alloc ObjectExpression<'alloc>) { + } + + fn visit_static_member_expression(&mut self, ast: &'alloc StaticMemberExpression<'alloc>) { + self.enter_static_member_expression(ast); + self.visit_expression_or_super(&ast.object); + self.visit_identifier_name(&ast.property); + self.leave_static_member_expression(ast); + } + + fn enter_static_member_expression(&mut self, ast: &'alloc StaticMemberExpression<'alloc>) { + } + + fn leave_static_member_expression(&mut self, ast: &'alloc StaticMemberExpression<'alloc>) { + } + + fn visit_private_field_expression(&mut self, ast: &'alloc PrivateFieldExpression<'alloc>) { + self.enter_private_field_expression(ast); + self.visit_expression_or_super(&ast.object); + self.visit_private_identifier(&ast.field); + self.leave_private_field_expression(ast); + } + + fn enter_private_field_expression(&mut self, ast: &'alloc PrivateFieldExpression<'alloc>) { + } + + fn leave_private_field_expression(&mut self, ast: &'alloc PrivateFieldExpression<'alloc>) { + } + + fn visit_template_expression_element(&mut self, ast: &'alloc TemplateExpressionElement<'alloc>) { + self.enter_template_expression_element(ast); + match ast { + TemplateExpressionElement::Expression(ast) => { + self.visit_enum_template_expression_element_variant_expression(ast) + } + TemplateExpressionElement::TemplateElement(ast) => { + self.visit_enum_template_expression_element_variant_template_element(ast) + } + } + self.leave_template_expression_element(ast); + } + + fn enter_template_expression_element(&mut self, ast: &'alloc TemplateExpressionElement<'alloc>) { + } + + fn leave_template_expression_element(&mut self, ast: &'alloc TemplateExpressionElement<'alloc>) { + } + + fn visit_enum_template_expression_element_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_template_expression_element_variant_expression(ast); + self.visit_expression(ast); + self.leave_enum_template_expression_element_variant_expression(ast); + } + + fn enter_enum_template_expression_element_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_template_expression_element_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_template_expression_element_variant_template_element( + &mut self, + ast: &'alloc TemplateElement, + ) { + self.enter_enum_template_expression_element_variant_template_element(ast); + self.visit_template_element(ast); + self.leave_enum_template_expression_element_variant_template_element(ast); + } + + fn enter_enum_template_expression_element_variant_template_element( + &mut self, + ast: &'alloc TemplateElement, + ) { + } + + fn leave_enum_template_expression_element_variant_template_element( + &mut self, + ast: &'alloc TemplateElement, + ) { + } + + fn visit_template_expression(&mut self, ast: &'alloc TemplateExpression<'alloc>) { + self.enter_template_expression(ast); + if let Some(item) = &ast.tag { + self.visit_expression(item); + } + for item in &ast.elements { + self.visit_template_expression_element(item); + } + self.leave_template_expression(ast); + } + + fn enter_template_expression(&mut self, ast: &'alloc TemplateExpression<'alloc>) { + } + + fn leave_template_expression(&mut self, ast: &'alloc TemplateExpression<'alloc>) { + } + + fn visit_variable_declaration_or_assignment_target(&mut self, ast: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>) { + self.enter_variable_declaration_or_assignment_target(ast); + match ast { + VariableDeclarationOrAssignmentTarget::VariableDeclaration(ast) => { + self.visit_enum_variable_declaration_or_assignment_target_variant_variable_declaration(ast) + } + VariableDeclarationOrAssignmentTarget::AssignmentTarget(ast) => { + self.visit_enum_variable_declaration_or_assignment_target_variant_assignment_target(ast) + } + } + self.leave_variable_declaration_or_assignment_target(ast); + } + + fn enter_variable_declaration_or_assignment_target(&mut self, ast: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>) { + } + + fn leave_variable_declaration_or_assignment_target(&mut self, ast: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>) { + } + + fn visit_enum_variable_declaration_or_assignment_target_variant_variable_declaration( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + self.enter_enum_variable_declaration_or_assignment_target_variant_variable_declaration(ast); + self.visit_variable_declaration(ast); + self.leave_enum_variable_declaration_or_assignment_target_variant_variable_declaration(ast); + } + + fn enter_enum_variable_declaration_or_assignment_target_variant_variable_declaration( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + } + + fn leave_enum_variable_declaration_or_assignment_target_variant_variable_declaration( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + } + + fn visit_enum_variable_declaration_or_assignment_target_variant_assignment_target( + &mut self, + ast: &'alloc AssignmentTarget<'alloc>, + ) { + self.enter_enum_variable_declaration_or_assignment_target_variant_assignment_target(ast); + self.visit_assignment_target(ast); + self.leave_enum_variable_declaration_or_assignment_target_variant_assignment_target(ast); + } + + fn enter_enum_variable_declaration_or_assignment_target_variant_assignment_target( + &mut self, + ast: &'alloc AssignmentTarget<'alloc>, + ) { + } + + fn leave_enum_variable_declaration_or_assignment_target_variant_assignment_target( + &mut self, + ast: &'alloc AssignmentTarget<'alloc>, + ) { + } + + fn visit_variable_declaration_or_expression(&mut self, ast: &'alloc VariableDeclarationOrExpression<'alloc>) { + self.enter_variable_declaration_or_expression(ast); + match ast { + VariableDeclarationOrExpression::VariableDeclaration(ast) => { + self.visit_enum_variable_declaration_or_expression_variant_variable_declaration(ast) + } + VariableDeclarationOrExpression::Expression(ast) => { + self.visit_enum_variable_declaration_or_expression_variant_expression(ast) + } + } + self.leave_variable_declaration_or_expression(ast); + } + + fn enter_variable_declaration_or_expression(&mut self, ast: &'alloc VariableDeclarationOrExpression<'alloc>) { + } + + fn leave_variable_declaration_or_expression(&mut self, ast: &'alloc VariableDeclarationOrExpression<'alloc>) { + } + + fn visit_enum_variable_declaration_or_expression_variant_variable_declaration( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + self.enter_enum_variable_declaration_or_expression_variant_variable_declaration(ast); + self.visit_variable_declaration(ast); + self.leave_enum_variable_declaration_or_expression_variant_variable_declaration(ast); + } + + fn enter_enum_variable_declaration_or_expression_variant_variable_declaration( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + } + + fn leave_enum_variable_declaration_or_expression_variant_variable_declaration( + &mut self, + ast: &'alloc VariableDeclaration<'alloc>, + ) { + } + + fn visit_enum_variable_declaration_or_expression_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_variable_declaration_or_expression_variant_expression(ast); + self.visit_expression(ast); + self.leave_enum_variable_declaration_or_expression_variant_expression(ast); + } + + fn enter_enum_variable_declaration_or_expression_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_variable_declaration_or_expression_variant_expression( + &mut self, + ast: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_block(&mut self, ast: &'alloc Block<'alloc>) { + self.enter_block(ast); + for item in &ast.statements { + self.visit_statement(item); + } + if let Some(item) = &ast.declarations { + for item in item { + } + } + self.leave_block(ast); + } + + fn enter_block(&mut self, ast: &'alloc Block<'alloc>) { + } + + fn leave_block(&mut self, ast: &'alloc Block<'alloc>) { + } + + fn visit_catch_clause(&mut self, ast: &'alloc CatchClause<'alloc>) { + self.enter_catch_clause(ast); + if let Some(item) = &ast.binding { + self.visit_binding(item); + } + self.visit_block(&ast.body); + self.leave_catch_clause(ast); + } + + fn enter_catch_clause(&mut self, ast: &'alloc CatchClause<'alloc>) { + } + + fn leave_catch_clause(&mut self, ast: &'alloc CatchClause<'alloc>) { + } + + fn visit_directive(&mut self, ast: &'alloc Directive) { + self.enter_directive(ast); + self.leave_directive(ast); + } + + fn enter_directive(&mut self, ast: &'alloc Directive) { + } + + fn leave_directive(&mut self, ast: &'alloc Directive) { + } + + fn visit_formal_parameters(&mut self, ast: &'alloc FormalParameters<'alloc>) { + self.enter_formal_parameters(ast); + for item in &ast.items { + self.visit_parameter(item); + } + if let Some(item) = &ast.rest { + self.visit_binding(item); + } + self.leave_formal_parameters(ast); + } + + fn enter_formal_parameters(&mut self, ast: &'alloc FormalParameters<'alloc>) { + } + + fn leave_formal_parameters(&mut self, ast: &'alloc FormalParameters<'alloc>) { + } + + fn visit_function_body(&mut self, ast: &'alloc FunctionBody<'alloc>) { + self.enter_function_body(ast); + for item in &ast.directives { + self.visit_directive(item); + } + for item in &ast.statements { + self.visit_statement(item); + } + self.leave_function_body(ast); + } + + fn enter_function_body(&mut self, ast: &'alloc FunctionBody<'alloc>) { + } + + fn leave_function_body(&mut self, ast: &'alloc FunctionBody<'alloc>) { + } + + fn visit_script(&mut self, ast: &'alloc Script<'alloc>) { + self.enter_script(ast); + for item in &ast.directives { + self.visit_directive(item); + } + for item in &ast.statements { + self.visit_statement(item); + } + self.leave_script(ast); + } + + fn enter_script(&mut self, ast: &'alloc Script<'alloc>) { + } + + fn leave_script(&mut self, ast: &'alloc Script<'alloc>) { + } + + fn visit_switch_case(&mut self, ast: &'alloc SwitchCase<'alloc>) { + self.enter_switch_case(ast); + self.visit_expression(&ast.test); + for item in &ast.consequent { + self.visit_statement(item); + } + self.leave_switch_case(ast); + } + + fn enter_switch_case(&mut self, ast: &'alloc SwitchCase<'alloc>) { + } + + fn leave_switch_case(&mut self, ast: &'alloc SwitchCase<'alloc>) { + } + + fn visit_switch_default(&mut self, ast: &'alloc SwitchDefault<'alloc>) { + self.enter_switch_default(ast); + for item in &ast.consequent { + self.visit_statement(item); + } + self.leave_switch_default(ast); + } + + fn enter_switch_default(&mut self, ast: &'alloc SwitchDefault<'alloc>) { + } + + fn leave_switch_default(&mut self, ast: &'alloc SwitchDefault<'alloc>) { + } + + fn visit_template_element(&mut self, ast: &'alloc TemplateElement) { + self.enter_template_element(ast); + self.leave_template_element(ast); + } + + fn enter_template_element(&mut self, ast: &'alloc TemplateElement) { + } + + fn leave_template_element(&mut self, ast: &'alloc TemplateElement) { + } + + fn visit_variable_declaration(&mut self, ast: &'alloc VariableDeclaration<'alloc>) { + self.enter_variable_declaration(ast); + self.visit_variable_declaration_kind(&ast.kind); + for item in &ast.declarators { + self.visit_variable_declarator(item); + } + self.leave_variable_declaration(ast); + } + + fn enter_variable_declaration(&mut self, ast: &'alloc VariableDeclaration<'alloc>) { + } + + fn leave_variable_declaration(&mut self, ast: &'alloc VariableDeclaration<'alloc>) { + } + + fn visit_variable_declarator(&mut self, ast: &'alloc VariableDeclarator<'alloc>) { + self.enter_variable_declarator(ast); + self.visit_binding(&ast.binding); + if let Some(item) = &ast.init { + self.visit_expression(item); + } + self.leave_variable_declarator(ast); + } + + fn enter_variable_declarator(&mut self, ast: &'alloc VariableDeclarator<'alloc>) { + } + + fn leave_variable_declarator(&mut self, ast: &'alloc VariableDeclarator<'alloc>) { + } + + fn visit_cover_parenthesized(&mut self, ast: &'alloc CoverParenthesized<'alloc>) { + self.enter_cover_parenthesized(ast); + match ast { + CoverParenthesized::Expression { expression, .. } => { + self.visit_enum_cover_parenthesized_variant_expression( + expression, + ) + } + CoverParenthesized::Parameters(ast) => { + self.visit_enum_cover_parenthesized_variant_parameters(ast) + } + } + self.leave_cover_parenthesized(ast); + } + + fn enter_cover_parenthesized(&mut self, ast: &'alloc CoverParenthesized<'alloc>) { + } + + fn leave_cover_parenthesized(&mut self, ast: &'alloc CoverParenthesized<'alloc>) { + } + + fn visit_enum_cover_parenthesized_variant_expression( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + self.enter_enum_cover_parenthesized_variant_expression( + expression, + ); + self.visit_expression(expression); + self.leave_enum_cover_parenthesized_variant_expression( + expression, + ); + } + + fn enter_enum_cover_parenthesized_variant_expression( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn leave_enum_cover_parenthesized_variant_expression( + &mut self, + expression: &'alloc arena::Box<'alloc, Expression<'alloc>>, + ) { + } + + fn visit_enum_cover_parenthesized_variant_parameters( + &mut self, + ast: &'alloc arena::Box<'alloc, FormalParameters<'alloc>>, + ) { + self.enter_enum_cover_parenthesized_variant_parameters(ast); + self.visit_formal_parameters(ast); + self.leave_enum_cover_parenthesized_variant_parameters(ast); + } + + fn enter_enum_cover_parenthesized_variant_parameters( + &mut self, + ast: &'alloc arena::Box<'alloc, FormalParameters<'alloc>>, + ) { + } + + fn leave_enum_cover_parenthesized_variant_parameters( + &mut self, + ast: &'alloc arena::Box<'alloc, FormalParameters<'alloc>>, + ) { + } + +} + |