Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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..24a6ac623d
--- /dev/null
+++ b/third_party/rust/jsparagus-ast/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"a2ec3cc2de80074959295ecce7a6c5a491377c73ba5751ccbf59953cf2d0667a","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..e4556efb63
--- /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 = "2.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>>,
+    ) {
+    }
+
+}
+