summaryrefslogtreecommitdiffstats
path: root/third_party/rust/jsparagus-ast/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--third_party/rust/jsparagus-ast/src/arena.rs85
-rw-r--r--third_party/rust/jsparagus-ast/src/associated_data.rs143
-rw-r--r--third_party/rust/jsparagus-ast/src/dump_generated.rs2269
-rw-r--r--third_party/rust/jsparagus-ast/src/lib.rs30
-rw-r--r--third_party/rust/jsparagus-ast/src/source_atom_set.rs221
-rw-r--r--third_party/rust/jsparagus-ast/src/source_location.rs32
-rw-r--r--third_party/rust/jsparagus-ast/src/source_location_accessor_generated.rs2047
-rw-r--r--third_party/rust/jsparagus-ast/src/source_slice_list.rs49
-rw-r--r--third_party/rust/jsparagus-ast/src/type_id_generated.rs712
-rw-r--r--third_party/rust/jsparagus-ast/src/types_generated.rs1055
-rw-r--r--third_party/rust/jsparagus-ast/src/visit_generated.rs5423
11 files changed, 12066 insertions, 0 deletions
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>>,
+ ) {
+ }
+
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-13 15:44:47 +0000