jsparagus-generated-parser/src/stack_value_generated.rs

// WARNING: This file is auto-generated by crates/ast/generate_ast.py.

use crate::token::Token;
use ast::arena;
use ast::types::*;
use std::convert::Infallible;

pub type AstError = String;
type AstResult<'alloc, T> = Result<arena::Box<'alloc, T>, AstError>;

#[derive(Debug)]
pub enum StackValue<'alloc> {
    Argument(arena::Box<'alloc, Argument<'alloc>>),
    Arguments(arena::Box<'alloc, Arguments<'alloc>>),
    ArrayAssignmentTarget(arena::Box<'alloc, ArrayAssignmentTarget<'alloc>>),
    ArrayBinding(arena::Box<'alloc, ArrayBinding<'alloc>>),
    ArrayExpression(arena::Box<'alloc, ArrayExpression<'alloc>>),
    ArrayExpressionElement(arena::Box<'alloc, ArrayExpressionElement<'alloc>>),
    ArrowExpressionBody(arena::Box<'alloc, ArrowExpressionBody<'alloc>>),
    AssignmentTarget(arena::Box<'alloc, AssignmentTarget<'alloc>>),
    AssignmentTargetIdentifier(arena::Box<'alloc, AssignmentTargetIdentifier>),
    AssignmentTargetMaybeDefault(arena::Box<'alloc, AssignmentTargetMaybeDefault<'alloc>>),
    AssignmentTargetPattern(arena::Box<'alloc, AssignmentTargetPattern<'alloc>>),
    AssignmentTargetProperty(arena::Box<'alloc, AssignmentTargetProperty<'alloc>>),
    AssignmentTargetPropertyIdentifier(arena::Box<'alloc, AssignmentTargetPropertyIdentifier<'alloc>>),
    AssignmentTargetPropertyProperty(arena::Box<'alloc, AssignmentTargetPropertyProperty<'alloc>>),
    AssignmentTargetWithDefault(arena::Box<'alloc, AssignmentTargetWithDefault<'alloc>>),
    BinaryOperator(arena::Box<'alloc, BinaryOperator>),
    Binding(arena::Box<'alloc, Binding<'alloc>>),
    BindingIdentifier(arena::Box<'alloc, BindingIdentifier>),
    BindingPattern(arena::Box<'alloc, BindingPattern<'alloc>>),
    BindingProperty(arena::Box<'alloc, BindingProperty<'alloc>>),
    BindingPropertyIdentifier(arena::Box<'alloc, BindingPropertyIdentifier<'alloc>>),
    BindingPropertyProperty(arena::Box<'alloc, BindingPropertyProperty<'alloc>>),
    BindingWithDefault(arena::Box<'alloc, BindingWithDefault<'alloc>>),
    Block(arena::Box<'alloc, Block<'alloc>>),
    CallExpression(arena::Box<'alloc, CallExpression<'alloc>>),
    CatchClause(arena::Box<'alloc, CatchClause<'alloc>>),
    ClassDeclaration(arena::Box<'alloc, ClassDeclaration<'alloc>>),
    ClassElement(arena::Box<'alloc, ClassElement<'alloc>>),
    ClassElementName(arena::Box<'alloc, ClassElementName<'alloc>>),
    ClassExpression(arena::Box<'alloc, ClassExpression<'alloc>>),
    CompoundAssignmentOperator(arena::Box<'alloc, CompoundAssignmentOperator>),
    ComputedMemberAssignmentTarget(arena::Box<'alloc, ComputedMemberAssignmentTarget<'alloc>>),
    ComputedMemberExpression(arena::Box<'alloc, ComputedMemberExpression<'alloc>>),
    ComputedPropertyName(arena::Box<'alloc, ComputedPropertyName<'alloc>>),
    CoverParenthesized(arena::Box<'alloc, CoverParenthesized<'alloc>>),
    DataProperty(arena::Box<'alloc, DataProperty<'alloc>>),
    Directive(arena::Box<'alloc, Directive>),
    Export(arena::Box<'alloc, Export<'alloc>>),
    ExportAllFrom(arena::Box<'alloc, ExportAllFrom>),
    ExportDeclaration(arena::Box<'alloc, ExportDeclaration<'alloc>>),
    ExportDefault(arena::Box<'alloc, ExportDefault<'alloc>>),
    ExportFrom(arena::Box<'alloc, ExportFrom<'alloc>>),
    ExportFromSpecifier(arena::Box<'alloc, ExportFromSpecifier>),
    ExportLocalSpecifier(arena::Box<'alloc, ExportLocalSpecifier>),
    ExportLocals(arena::Box<'alloc, ExportLocals<'alloc>>),
    Expression(arena::Box<'alloc, Expression<'alloc>>),
    ExpressionOrSuper(arena::Box<'alloc, ExpressionOrSuper<'alloc>>),
    FormalParameters(arena::Box<'alloc, FormalParameters<'alloc>>),
    Function(arena::Box<'alloc, Function<'alloc>>),
    FunctionBody(arena::Box<'alloc, FunctionBody<'alloc>>),
    Getter(arena::Box<'alloc, Getter<'alloc>>),
    Identifier(arena::Box<'alloc, Identifier>),
    IdentifierExpression(arena::Box<'alloc, IdentifierExpression>),
    IdentifierName(arena::Box<'alloc, IdentifierName>),
    IfStatement(arena::Box<'alloc, IfStatement<'alloc>>),
    Import(arena::Box<'alloc, Import<'alloc>>),
    ImportDeclaration(arena::Box<'alloc, ImportDeclaration<'alloc>>),
    ImportNamespace(arena::Box<'alloc, ImportNamespace>),
    ImportSpecifier(arena::Box<'alloc, ImportSpecifier>),
    Label(arena::Box<'alloc, Label>),
    MemberAssignmentTarget(arena::Box<'alloc, MemberAssignmentTarget<'alloc>>),
    MemberExpression(arena::Box<'alloc, MemberExpression<'alloc>>),
    Method(arena::Box<'alloc, Method<'alloc>>),
    MethodDefinition(arena::Box<'alloc, MethodDefinition<'alloc>>),
    Module(arena::Box<'alloc, Module<'alloc>>),
    ModuleItems(arena::Box<'alloc, ModuleItems<'alloc>>),
    NamedObjectProperty(arena::Box<'alloc, NamedObjectProperty<'alloc>>),
    NumericLiteral(arena::Box<'alloc, NumericLiteral>),
    ObjectAssignmentTarget(arena::Box<'alloc, ObjectAssignmentTarget<'alloc>>),
    ObjectBinding(arena::Box<'alloc, ObjectBinding<'alloc>>),
    ObjectExpression(arena::Box<'alloc, ObjectExpression<'alloc>>),
    ObjectProperty(arena::Box<'alloc, ObjectProperty<'alloc>>),
    OptionalChain(arena::Box<'alloc, OptionalChain<'alloc>>),
    Parameter(arena::Box<'alloc, Parameter<'alloc>>),
    PrivateFieldExpression(arena::Box<'alloc, PrivateFieldExpression<'alloc>>),
    PrivateIdentifier(arena::Box<'alloc, PrivateIdentifier>),
    Program(arena::Box<'alloc, Program<'alloc>>),
    PropertyName(arena::Box<'alloc, PropertyName<'alloc>>),
    Script(arena::Box<'alloc, Script<'alloc>>),
    Setter(arena::Box<'alloc, Setter<'alloc>>),
    ShorthandProperty(arena::Box<'alloc, ShorthandProperty>),
    SimpleAssignmentTarget(arena::Box<'alloc, SimpleAssignmentTarget<'alloc>>),
    Statement(arena::Box<'alloc, Statement<'alloc>>),
    StaticMemberAssignmentTarget(arena::Box<'alloc, StaticMemberAssignmentTarget<'alloc>>),
    StaticMemberExpression(arena::Box<'alloc, StaticMemberExpression<'alloc>>),
    StaticPropertyName(arena::Box<'alloc, StaticPropertyName>),
    SwitchCase(arena::Box<'alloc, SwitchCase<'alloc>>),
    SwitchDefault(arena::Box<'alloc, SwitchDefault<'alloc>>),
    TemplateElement(arena::Box<'alloc, TemplateElement>),
    TemplateExpression(arena::Box<'alloc, TemplateExpression<'alloc>>),
    TemplateExpressionElement(arena::Box<'alloc, TemplateExpressionElement<'alloc>>),
    Token(arena::Box<'alloc, Token>),
    UnaryOperator(arena::Box<'alloc, UnaryOperator>),
    UpdateOperator(arena::Box<'alloc, UpdateOperator>),
    VariableDeclaration(arena::Box<'alloc, VariableDeclaration<'alloc>>),
    VariableDeclarationKind(arena::Box<'alloc, VariableDeclarationKind>),
    VariableDeclarationOrAssignmentTarget(arena::Box<'alloc, VariableDeclarationOrAssignmentTarget<'alloc>>),
    VariableDeclarationOrExpression(arena::Box<'alloc, VariableDeclarationOrExpression<'alloc>>),
    VariableDeclarator(arena::Box<'alloc, VariableDeclarator<'alloc>>),
    VariableReference(arena::Box<'alloc, VariableReference>),
    VecArrayExpressionElement(arena::Box<'alloc, arena::Vec<'alloc, ArrayExpressionElement<'alloc>>>),
    VecBindingProperty(arena::Box<'alloc, arena::Vec<'alloc, BindingProperty<'alloc>>>),
    VecClassElement(arena::Box<'alloc, arena::Vec<'alloc, arena::Box<'alloc, ClassElement<'alloc>>>>),
    VecOption(arena::Box<'alloc, arena::Vec<'alloc, Option<Parameter<'alloc>>>>),
    VecStatement(arena::Box<'alloc, arena::Vec<'alloc, Statement<'alloc>>>),
    VecSwitchCase(arena::Box<'alloc, arena::Vec<'alloc, SwitchCase<'alloc>>>),
    VecVariableDeclarator(arena::Box<'alloc, arena::Vec<'alloc, VariableDeclarator<'alloc>>>),
    Void(arena::Box<'alloc, Void>),
}

impl<'alloc> StackValue<'alloc> {
    pub fn to_ast<T: StackValueItem<'alloc>>(self) -> AstResult<'alloc, T> {
        T::to_ast(self)
    }
}

pub trait StackValueItem<'alloc>: Sized {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self>;
}

/// Values that can be converted to StackValues, fallibly.
pub trait TryIntoStack<'alloc> {
    type Error;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Self::Error>;
}
impl<'alloc> StackValueItem<'alloc> for Argument<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Argument(v) => Ok(v),
            _ => Err(format!("StackValue expected Argument, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Arguments<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Arguments(v) => Ok(v),
            _ => Err(format!("StackValue expected Arguments, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ArrayAssignmentTarget<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ArrayAssignmentTarget(v) => Ok(v),
            _ => Err(format!("StackValue expected ArrayAssignmentTarget, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ArrayBinding<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ArrayBinding(v) => Ok(v),
            _ => Err(format!("StackValue expected ArrayBinding, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ArrayExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ArrayExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected ArrayExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ArrayExpressionElement<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ArrayExpressionElement(v) => Ok(v),
            _ => Err(format!("StackValue expected ArrayExpressionElement, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ArrowExpressionBody<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ArrowExpressionBody(v) => Ok(v),
            _ => Err(format!("StackValue expected ArrowExpressionBody, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for AssignmentTarget<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::AssignmentTarget(v) => Ok(v),
            _ => Err(format!("StackValue expected AssignmentTarget, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for AssignmentTargetIdentifier {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::AssignmentTargetIdentifier(v) => Ok(v),
            _ => Err(format!("StackValue expected AssignmentTargetIdentifier, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for AssignmentTargetMaybeDefault<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::AssignmentTargetMaybeDefault(v) => Ok(v),
            _ => Err(format!("StackValue expected AssignmentTargetMaybeDefault, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for AssignmentTargetPattern<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::AssignmentTargetPattern(v) => Ok(v),
            _ => Err(format!("StackValue expected AssignmentTargetPattern, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for AssignmentTargetProperty<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::AssignmentTargetProperty(v) => Ok(v),
            _ => Err(format!("StackValue expected AssignmentTargetProperty, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for AssignmentTargetPropertyIdentifier<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::AssignmentTargetPropertyIdentifier(v) => Ok(v),
            _ => Err(format!("StackValue expected AssignmentTargetPropertyIdentifier, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for AssignmentTargetPropertyProperty<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::AssignmentTargetPropertyProperty(v) => Ok(v),
            _ => Err(format!("StackValue expected AssignmentTargetPropertyProperty, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for AssignmentTargetWithDefault<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::AssignmentTargetWithDefault(v) => Ok(v),
            _ => Err(format!("StackValue expected AssignmentTargetWithDefault, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for BinaryOperator {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::BinaryOperator(v) => Ok(v),
            _ => Err(format!("StackValue expected BinaryOperator, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Binding<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Binding(v) => Ok(v),
            _ => Err(format!("StackValue expected Binding, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for BindingIdentifier {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::BindingIdentifier(v) => Ok(v),
            _ => Err(format!("StackValue expected BindingIdentifier, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for BindingPattern<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::BindingPattern(v) => Ok(v),
            _ => Err(format!("StackValue expected BindingPattern, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for BindingProperty<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::BindingProperty(v) => Ok(v),
            _ => Err(format!("StackValue expected BindingProperty, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for BindingPropertyIdentifier<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::BindingPropertyIdentifier(v) => Ok(v),
            _ => Err(format!("StackValue expected BindingPropertyIdentifier, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for BindingPropertyProperty<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::BindingPropertyProperty(v) => Ok(v),
            _ => Err(format!("StackValue expected BindingPropertyProperty, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for BindingWithDefault<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::BindingWithDefault(v) => Ok(v),
            _ => Err(format!("StackValue expected BindingWithDefault, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Block<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Block(v) => Ok(v),
            _ => Err(format!("StackValue expected Block, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for CallExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::CallExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected CallExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for CatchClause<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::CatchClause(v) => Ok(v),
            _ => Err(format!("StackValue expected CatchClause, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ClassDeclaration<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ClassDeclaration(v) => Ok(v),
            _ => Err(format!("StackValue expected ClassDeclaration, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ClassElement<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ClassElement(v) => Ok(v),
            _ => Err(format!("StackValue expected ClassElement, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ClassElementName<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ClassElementName(v) => Ok(v),
            _ => Err(format!("StackValue expected ClassElementName, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ClassExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ClassExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected ClassExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for CompoundAssignmentOperator {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::CompoundAssignmentOperator(v) => Ok(v),
            _ => Err(format!("StackValue expected CompoundAssignmentOperator, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ComputedMemberAssignmentTarget<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ComputedMemberAssignmentTarget(v) => Ok(v),
            _ => Err(format!("StackValue expected ComputedMemberAssignmentTarget, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ComputedMemberExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ComputedMemberExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected ComputedMemberExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ComputedPropertyName<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ComputedPropertyName(v) => Ok(v),
            _ => Err(format!("StackValue expected ComputedPropertyName, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for CoverParenthesized<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::CoverParenthesized(v) => Ok(v),
            _ => Err(format!("StackValue expected CoverParenthesized, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for DataProperty<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::DataProperty(v) => Ok(v),
            _ => Err(format!("StackValue expected DataProperty, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Directive {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Directive(v) => Ok(v),
            _ => Err(format!("StackValue expected Directive, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Export<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Export(v) => Ok(v),
            _ => Err(format!("StackValue expected Export, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ExportAllFrom {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ExportAllFrom(v) => Ok(v),
            _ => Err(format!("StackValue expected ExportAllFrom, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ExportDeclaration<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ExportDeclaration(v) => Ok(v),
            _ => Err(format!("StackValue expected ExportDeclaration, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ExportDefault<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ExportDefault(v) => Ok(v),
            _ => Err(format!("StackValue expected ExportDefault, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ExportFrom<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ExportFrom(v) => Ok(v),
            _ => Err(format!("StackValue expected ExportFrom, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ExportFromSpecifier {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ExportFromSpecifier(v) => Ok(v),
            _ => Err(format!("StackValue expected ExportFromSpecifier, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ExportLocalSpecifier {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ExportLocalSpecifier(v) => Ok(v),
            _ => Err(format!("StackValue expected ExportLocalSpecifier, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ExportLocals<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ExportLocals(v) => Ok(v),
            _ => Err(format!("StackValue expected ExportLocals, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Expression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Expression(v) => Ok(v),
            _ => Err(format!("StackValue expected Expression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ExpressionOrSuper<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ExpressionOrSuper(v) => Ok(v),
            _ => Err(format!("StackValue expected ExpressionOrSuper, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for FormalParameters<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::FormalParameters(v) => Ok(v),
            _ => Err(format!("StackValue expected FormalParameters, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Function<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Function(v) => Ok(v),
            _ => Err(format!("StackValue expected Function, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for FunctionBody<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::FunctionBody(v) => Ok(v),
            _ => Err(format!("StackValue expected FunctionBody, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Getter<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Getter(v) => Ok(v),
            _ => Err(format!("StackValue expected Getter, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Identifier {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Identifier(v) => Ok(v),
            _ => Err(format!("StackValue expected Identifier, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for IdentifierExpression {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::IdentifierExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected IdentifierExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for IdentifierName {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::IdentifierName(v) => Ok(v),
            _ => Err(format!("StackValue expected IdentifierName, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for IfStatement<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::IfStatement(v) => Ok(v),
            _ => Err(format!("StackValue expected IfStatement, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Import<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Import(v) => Ok(v),
            _ => Err(format!("StackValue expected Import, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ImportDeclaration<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ImportDeclaration(v) => Ok(v),
            _ => Err(format!("StackValue expected ImportDeclaration, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ImportNamespace {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ImportNamespace(v) => Ok(v),
            _ => Err(format!("StackValue expected ImportNamespace, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ImportSpecifier {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ImportSpecifier(v) => Ok(v),
            _ => Err(format!("StackValue expected ImportSpecifier, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Label {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Label(v) => Ok(v),
            _ => Err(format!("StackValue expected Label, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for MemberAssignmentTarget<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::MemberAssignmentTarget(v) => Ok(v),
            _ => Err(format!("StackValue expected MemberAssignmentTarget, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for MemberExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::MemberExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected MemberExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Method<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Method(v) => Ok(v),
            _ => Err(format!("StackValue expected Method, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for MethodDefinition<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::MethodDefinition(v) => Ok(v),
            _ => Err(format!("StackValue expected MethodDefinition, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Module<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Module(v) => Ok(v),
            _ => Err(format!("StackValue expected Module, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ModuleItems<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ModuleItems(v) => Ok(v),
            _ => Err(format!("StackValue expected ModuleItems, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for NamedObjectProperty<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::NamedObjectProperty(v) => Ok(v),
            _ => Err(format!("StackValue expected NamedObjectProperty, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for NumericLiteral {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::NumericLiteral(v) => Ok(v),
            _ => Err(format!("StackValue expected NumericLiteral, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ObjectAssignmentTarget<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ObjectAssignmentTarget(v) => Ok(v),
            _ => Err(format!("StackValue expected ObjectAssignmentTarget, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ObjectBinding<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ObjectBinding(v) => Ok(v),
            _ => Err(format!("StackValue expected ObjectBinding, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ObjectExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ObjectExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected ObjectExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ObjectProperty<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ObjectProperty(v) => Ok(v),
            _ => Err(format!("StackValue expected ObjectProperty, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for OptionalChain<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::OptionalChain(v) => Ok(v),
            _ => Err(format!("StackValue expected OptionalChain, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Parameter<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Parameter(v) => Ok(v),
            _ => Err(format!("StackValue expected Parameter, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for PrivateFieldExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::PrivateFieldExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected PrivateFieldExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for PrivateIdentifier {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::PrivateIdentifier(v) => Ok(v),
            _ => Err(format!("StackValue expected PrivateIdentifier, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Program<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Program(v) => Ok(v),
            _ => Err(format!("StackValue expected Program, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for PropertyName<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::PropertyName(v) => Ok(v),
            _ => Err(format!("StackValue expected PropertyName, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Script<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Script(v) => Ok(v),
            _ => Err(format!("StackValue expected Script, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Setter<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Setter(v) => Ok(v),
            _ => Err(format!("StackValue expected Setter, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for ShorthandProperty {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::ShorthandProperty(v) => Ok(v),
            _ => Err(format!("StackValue expected ShorthandProperty, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for SimpleAssignmentTarget<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::SimpleAssignmentTarget(v) => Ok(v),
            _ => Err(format!("StackValue expected SimpleAssignmentTarget, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Statement<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Statement(v) => Ok(v),
            _ => Err(format!("StackValue expected Statement, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for StaticMemberAssignmentTarget<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::StaticMemberAssignmentTarget(v) => Ok(v),
            _ => Err(format!("StackValue expected StaticMemberAssignmentTarget, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for StaticMemberExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::StaticMemberExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected StaticMemberExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for StaticPropertyName {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::StaticPropertyName(v) => Ok(v),
            _ => Err(format!("StackValue expected StaticPropertyName, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for SwitchCase<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::SwitchCase(v) => Ok(v),
            _ => Err(format!("StackValue expected SwitchCase, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for SwitchDefault<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::SwitchDefault(v) => Ok(v),
            _ => Err(format!("StackValue expected SwitchDefault, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for TemplateElement {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::TemplateElement(v) => Ok(v),
            _ => Err(format!("StackValue expected TemplateElement, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for TemplateExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::TemplateExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected TemplateExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for TemplateExpressionElement<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::TemplateExpressionElement(v) => Ok(v),
            _ => Err(format!("StackValue expected TemplateExpressionElement, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Token {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Token(v) => Ok(v),
            _ => Err(format!("StackValue expected Token, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for UnaryOperator {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::UnaryOperator(v) => Ok(v),
            _ => Err(format!("StackValue expected UnaryOperator, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for UpdateOperator {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::UpdateOperator(v) => Ok(v),
            _ => Err(format!("StackValue expected UpdateOperator, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for VariableDeclaration<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VariableDeclaration(v) => Ok(v),
            _ => Err(format!("StackValue expected VariableDeclaration, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for VariableDeclarationKind {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VariableDeclarationKind(v) => Ok(v),
            _ => Err(format!("StackValue expected VariableDeclarationKind, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for VariableDeclarationOrAssignmentTarget<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VariableDeclarationOrAssignmentTarget(v) => Ok(v),
            _ => Err(format!("StackValue expected VariableDeclarationOrAssignmentTarget, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for VariableDeclarationOrExpression<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VariableDeclarationOrExpression(v) => Ok(v),
            _ => Err(format!("StackValue expected VariableDeclarationOrExpression, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for VariableDeclarator<'alloc> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VariableDeclarator(v) => Ok(v),
            _ => Err(format!("StackValue expected VariableDeclarator, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for VariableReference {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VariableReference(v) => Ok(v),
            _ => Err(format!("StackValue expected VariableReference, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for arena::Vec<'alloc, ArrayExpressionElement<'alloc>> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VecArrayExpressionElement(v) => Ok(v),
            _ => Err(format!("StackValue expected Vec<ArrayExpressionElement>, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for arena::Vec<'alloc, BindingProperty<'alloc>> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VecBindingProperty(v) => Ok(v),
            _ => Err(format!("StackValue expected Vec<BindingProperty>, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for arena::Vec<'alloc, arena::Box<'alloc, ClassElement<'alloc>>> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VecClassElement(v) => Ok(v),
            _ => Err(format!("StackValue expected Vec<Box<ClassElement>>, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for arena::Vec<'alloc, Option<Parameter<'alloc>>> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VecOption(v) => Ok(v),
            _ => Err(format!("StackValue expected Vec<Option<Parameter>>, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for arena::Vec<'alloc, Statement<'alloc>> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VecStatement(v) => Ok(v),
            _ => Err(format!("StackValue expected Vec<Statement>, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for arena::Vec<'alloc, SwitchCase<'alloc>> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VecSwitchCase(v) => Ok(v),
            _ => Err(format!("StackValue expected Vec<SwitchCase>, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for arena::Vec<'alloc, VariableDeclarator<'alloc>> {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::VecVariableDeclarator(v) => Ok(v),
            _ => Err(format!("StackValue expected Vec<VariableDeclarator>, got {:?}", sv)),
        }
    }
}

impl<'alloc> StackValueItem<'alloc> for Void {
    fn to_ast(sv: StackValue<'alloc>) -> AstResult<'alloc, Self> {
        match sv {
            StackValue::Void(v) => Ok(v),
            _ => Err(format!("StackValue expected Void, got {:?}", sv)),
        }
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Argument<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Argument(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Arguments<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Arguments(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ArrayAssignmentTarget<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ArrayAssignmentTarget(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ArrayBinding<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ArrayBinding(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ArrayExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ArrayExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ArrayExpressionElement<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ArrayExpressionElement(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ArrowExpressionBody<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ArrowExpressionBody(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, AssignmentTarget<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::AssignmentTarget(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, AssignmentTargetIdentifier> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::AssignmentTargetIdentifier(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, AssignmentTargetMaybeDefault<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::AssignmentTargetMaybeDefault(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, AssignmentTargetPattern<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::AssignmentTargetPattern(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, AssignmentTargetProperty<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::AssignmentTargetProperty(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, AssignmentTargetPropertyIdentifier<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::AssignmentTargetPropertyIdentifier(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, AssignmentTargetPropertyProperty<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::AssignmentTargetPropertyProperty(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, AssignmentTargetWithDefault<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::AssignmentTargetWithDefault(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, BinaryOperator> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::BinaryOperator(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Binding<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Binding(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, BindingIdentifier> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::BindingIdentifier(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, BindingPattern<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::BindingPattern(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, BindingProperty<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::BindingProperty(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, BindingPropertyIdentifier<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::BindingPropertyIdentifier(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, BindingPropertyProperty<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::BindingPropertyProperty(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, BindingWithDefault<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::BindingWithDefault(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Block<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Block(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, CallExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::CallExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, CatchClause<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::CatchClause(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ClassDeclaration<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ClassDeclaration(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ClassElement<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ClassElement(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ClassElementName<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ClassElementName(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ClassExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ClassExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, CompoundAssignmentOperator> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::CompoundAssignmentOperator(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ComputedMemberAssignmentTarget<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ComputedMemberAssignmentTarget(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ComputedMemberExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ComputedMemberExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ComputedPropertyName<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ComputedPropertyName(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, CoverParenthesized<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::CoverParenthesized(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, DataProperty<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::DataProperty(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Directive> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Directive(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Export<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Export(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ExportAllFrom> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ExportAllFrom(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ExportDeclaration<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ExportDeclaration(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ExportDefault<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ExportDefault(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ExportFrom<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ExportFrom(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ExportFromSpecifier> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ExportFromSpecifier(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ExportLocalSpecifier> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ExportLocalSpecifier(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ExportLocals<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ExportLocals(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Expression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Expression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ExpressionOrSuper<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ExpressionOrSuper(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, FormalParameters<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::FormalParameters(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Function<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Function(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, FunctionBody<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::FunctionBody(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Getter<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Getter(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Identifier> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Identifier(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, IdentifierExpression> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::IdentifierExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, IdentifierName> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::IdentifierName(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, IfStatement<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::IfStatement(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Import<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Import(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ImportDeclaration<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ImportDeclaration(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ImportNamespace> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ImportNamespace(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ImportSpecifier> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ImportSpecifier(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Label> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Label(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, MemberAssignmentTarget<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::MemberAssignmentTarget(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, MemberExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::MemberExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Method<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Method(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, MethodDefinition<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::MethodDefinition(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Module<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Module(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ModuleItems<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ModuleItems(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, NamedObjectProperty<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::NamedObjectProperty(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, NumericLiteral> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::NumericLiteral(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ObjectAssignmentTarget<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ObjectAssignmentTarget(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ObjectBinding<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ObjectBinding(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ObjectExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ObjectExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ObjectProperty<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ObjectProperty(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, OptionalChain<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::OptionalChain(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Parameter<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Parameter(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, PrivateFieldExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::PrivateFieldExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, PrivateIdentifier> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::PrivateIdentifier(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Program<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Program(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, PropertyName<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::PropertyName(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Script<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Script(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Setter<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Setter(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, ShorthandProperty> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::ShorthandProperty(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, SimpleAssignmentTarget<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::SimpleAssignmentTarget(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Statement<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Statement(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, StaticMemberAssignmentTarget<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::StaticMemberAssignmentTarget(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, StaticMemberExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::StaticMemberExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, StaticPropertyName> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::StaticPropertyName(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, SwitchCase<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::SwitchCase(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, SwitchDefault<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::SwitchDefault(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, TemplateElement> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::TemplateElement(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, TemplateExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::TemplateExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, TemplateExpressionElement<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::TemplateExpressionElement(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Token> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Token(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, UnaryOperator> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::UnaryOperator(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, UpdateOperator> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::UpdateOperator(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, VariableDeclaration<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VariableDeclaration(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, VariableDeclarationKind> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VariableDeclarationKind(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, VariableDeclarationOrAssignmentTarget<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VariableDeclarationOrAssignmentTarget(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, VariableDeclarationOrExpression<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VariableDeclarationOrExpression(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, VariableDeclarator<'alloc>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VariableDeclarator(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, VariableReference> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VariableReference(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, arena::Vec<'alloc, ArrayExpressionElement<'alloc>>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VecArrayExpressionElement(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, arena::Vec<'alloc, BindingProperty<'alloc>>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VecBindingProperty(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, arena::Vec<'alloc, arena::Box<'alloc, ClassElement<'alloc>>>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VecClassElement(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, arena::Vec<'alloc, Option<Parameter<'alloc>>>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VecOption(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, arena::Vec<'alloc, Statement<'alloc>>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VecStatement(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, arena::Vec<'alloc, SwitchCase<'alloc>>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VecSwitchCase(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, arena::Vec<'alloc, VariableDeclarator<'alloc>>> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::VecVariableDeclarator(self))
    }
}

impl<'alloc> TryIntoStack<'alloc> for arena::Box<'alloc, Void> {
    type Error = Infallible;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, Infallible> {
        Ok(StackValue::Void(self))
    }
}

impl<'alloc, T, E> TryIntoStack<'alloc> for Result<T, E>
where
    T: TryIntoStack<'alloc>,
    E: From<T::Error>,
{
    type Error = E;
    fn try_into_stack(self) -> Result<StackValue<'alloc>, E> {
        Ok(self?.try_into_stack()?)
    }
}