Quelle dump_generated.rs
Sprache: unbekannt
|
|
// 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> {
--> --------------------
--> maximum size reached
--> --------------------
[ Dauer der Verarbeitung: 0.20 Sekunden
(vorverarbeitet)
]
|
2026-04-04
|
