hermes_ast/

node.rs

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

//! @generated by gen_nodes.py from include/hermes/AST/ESTree.def — DO NOT EDIT.
//! Run `python3 rust/crates/ast/gen_nodes.py` to regenerate.
#![allow(non_camel_case_types)] // NodeKind range sentinels (_Name_First/_Last) mirror C++
#![allow(clippy::too_many_arguments)] // node `new` arity follows ESTree.def (up to 10 args)
#![allow(clippy::large_enum_variant)] // one enum over all nodes — boxing would defeat deep-match

use std::cell::Cell;
use crate::node_child::{NodeChild, NodeLabel, NodeList, NodeMetadata, NodeString, Strictness, INVALID_LABEL};
use crate::visitor::{Path, TransformResult, Visitor, VisitorMut};
use crate::NodeId;
use crate::SemaId;

/// The kind discriminant of an AST node.
///
/// Mirrors the C++ `NodeKind` enum: `#[repr(u32)]`, `ESTree.def` order,
/// with `_Name_First`/`_Last` sentinels interleaved so the `Node::is_*`
/// range predicates are two integer comparisons.
#[repr(u32)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum NodeKind {
    /// The kind of [`Empty`].
    Empty,
    /// The kind of [`Metadata`].
    Metadata,
    /// Exclusive lower bound of the `FunctionLike` range.
    _FunctionLike_First,
    /// The kind of [`Program`].
    Program,
    /// The kind of [`FunctionExpression`].
    FunctionExpression,
    /// The kind of [`ArrowFunctionExpression`].
    ArrowFunctionExpression,
    /// The kind of [`FunctionDeclaration`].
    FunctionDeclaration,
    /// The kind of [`ComponentDeclaration`].
    ComponentDeclaration,
    /// The kind of [`HookDeclaration`].
    HookDeclaration,
    /// Exclusive upper bound of the `FunctionLike` range.
    _FunctionLike_Last,
    /// Exclusive lower bound of the `Statement` range.
    _Statement_First,
    /// The kind of [`MatchStatement`].
    MatchStatement,
    /// Exclusive lower bound of the `LoopStatement` range.
    _LoopStatement_First,
    /// The kind of [`WhileStatement`].
    WhileStatement,
    /// The kind of [`DoWhileStatement`].
    DoWhileStatement,
    /// The kind of [`ForInStatement`].
    ForInStatement,
    /// The kind of [`ForOfStatement`].
    ForOfStatement,
    /// The kind of [`ForStatement`].
    ForStatement,
    /// Exclusive upper bound of the `LoopStatement` range.
    _LoopStatement_Last,
    /// The kind of [`DebuggerStatement`].
    DebuggerStatement,
    /// The kind of [`EmptyStatement`].
    EmptyStatement,
    /// The kind of [`BlockStatement`].
    BlockStatement,
    /// The kind of [`StaticBlock`].
    StaticBlock,
    /// The kind of [`BreakStatement`].
    BreakStatement,
    /// The kind of [`ContinueStatement`].
    ContinueStatement,
    /// The kind of [`ThrowStatement`].
    ThrowStatement,
    /// The kind of [`ReturnStatement`].
    ReturnStatement,
    /// The kind of [`WithStatement`].
    WithStatement,
    /// The kind of [`SwitchStatement`].
    SwitchStatement,
    /// The kind of [`LabeledStatement`].
    LabeledStatement,
    /// The kind of [`ExpressionStatement`].
    ExpressionStatement,
    /// The kind of [`TryStatement`].
    TryStatement,
    /// The kind of [`IfStatement`].
    IfStatement,
    /// Exclusive upper bound of the `Statement` range.
    _Statement_Last,
    /// The kind of [`NullLiteral`].
    NullLiteral,
    /// The kind of [`BooleanLiteral`].
    BooleanLiteral,
    /// The kind of [`StringLiteral`].
    StringLiteral,
    /// The kind of [`NumericLiteral`].
    NumericLiteral,
    /// The kind of [`RegExpLiteral`].
    RegExpLiteral,
    /// The kind of [`BigIntLiteral`].
    BigIntLiteral,
    /// The kind of [`ThisExpression`].
    ThisExpression,
    /// The kind of [`Super`].
    Super,
    /// The kind of [`SequenceExpression`].
    SequenceExpression,
    /// The kind of [`ObjectExpression`].
    ObjectExpression,
    /// The kind of [`ArrayExpression`].
    ArrayExpression,
    /// The kind of [`SpreadElement`].
    SpreadElement,
    /// The kind of [`NewExpression`].
    NewExpression,
    /// The kind of [`YieldExpression`].
    YieldExpression,
    /// The kind of [`AwaitExpression`].
    AwaitExpression,
    /// The kind of [`ImportExpression`].
    ImportExpression,
    /// Exclusive lower bound of the `CallExpressionLike` range.
    _CallExpressionLike_First,
    /// The kind of [`CallExpression`].
    CallExpression,
    /// The kind of [`OptionalCallExpression`].
    OptionalCallExpression,
    /// Exclusive upper bound of the `CallExpressionLike` range.
    _CallExpressionLike_Last,
    /// The kind of [`AssignmentExpression`].
    AssignmentExpression,
    /// The kind of [`UnaryExpression`].
    UnaryExpression,
    /// The kind of [`UpdateExpression`].
    UpdateExpression,
    /// Exclusive lower bound of the `MemberExpressionLike` range.
    _MemberExpressionLike_First,
    /// The kind of [`MemberExpression`].
    MemberExpression,
    /// The kind of [`OptionalMemberExpression`].
    OptionalMemberExpression,
    /// Exclusive upper bound of the `MemberExpressionLike` range.
    _MemberExpressionLike_Last,
    /// The kind of [`LogicalExpression`].
    LogicalExpression,
    /// The kind of [`ConditionalExpression`].
    ConditionalExpression,
    /// The kind of [`BinaryExpression`].
    BinaryExpression,
    /// The kind of [`Directive`].
    Directive,
    /// The kind of [`DirectiveLiteral`].
    DirectiveLiteral,
    /// The kind of [`Identifier`].
    Identifier,
    /// The kind of [`PrivateName`].
    PrivateName,
    /// The kind of [`MetaProperty`].
    MetaProperty,
    /// The kind of [`SwitchCase`].
    SwitchCase,
    /// The kind of [`CatchClause`].
    CatchClause,
    /// The kind of [`VariableDeclarator`].
    VariableDeclarator,
    /// The kind of [`VariableDeclaration`].
    VariableDeclaration,
    /// The kind of [`TemplateLiteral`].
    TemplateLiteral,
    /// The kind of [`TaggedTemplateExpression`].
    TaggedTemplateExpression,
    /// The kind of [`TemplateElement`].
    TemplateElement,
    /// The kind of [`Property`].
    Property,
    /// The kind of [`Decorator`].
    Decorator,
    /// Exclusive lower bound of the `ClassLike` range.
    _ClassLike_First,
    /// The kind of [`ClassDeclaration`].
    ClassDeclaration,
    /// The kind of [`ClassExpression`].
    ClassExpression,
    /// Exclusive upper bound of the `ClassLike` range.
    _ClassLike_Last,
    /// The kind of [`ClassBody`].
    ClassBody,
    /// The kind of [`ClassProperty`].
    ClassProperty,
    /// The kind of [`ClassPrivateProperty`].
    ClassPrivateProperty,
    /// The kind of [`MethodDefinition`].
    MethodDefinition,
    /// The kind of [`ImportDeclaration`].
    ImportDeclaration,
    /// The kind of [`ImportSpecifier`].
    ImportSpecifier,
    /// The kind of [`ImportDefaultSpecifier`].
    ImportDefaultSpecifier,
    /// The kind of [`ImportNamespaceSpecifier`].
    ImportNamespaceSpecifier,
    /// The kind of [`ImportAttribute`].
    ImportAttribute,
    /// The kind of [`ExportNamedDeclaration`].
    ExportNamedDeclaration,
    /// The kind of [`ExportSpecifier`].
    ExportSpecifier,
    /// The kind of [`ExportNamespaceSpecifier`].
    ExportNamespaceSpecifier,
    /// The kind of [`ExportDefaultDeclaration`].
    ExportDefaultDeclaration,
    /// The kind of [`ExportAllDeclaration`].
    ExportAllDeclaration,
    /// Exclusive lower bound of the `Pattern` range.
    _Pattern_First,
    /// The kind of [`ObjectPattern`].
    ObjectPattern,
    /// The kind of [`ArrayPattern`].
    ArrayPattern,
    /// The kind of [`RestElement`].
    RestElement,
    /// The kind of [`AssignmentPattern`].
    AssignmentPattern,
    /// Exclusive upper bound of the `Pattern` range.
    _Pattern_Last,
    /// The kind of [`MatchStatementCase`].
    MatchStatementCase,
    /// The kind of [`MatchExpression`].
    MatchExpression,
    /// The kind of [`MatchExpressionCase`].
    MatchExpressionCase,
    /// Exclusive lower bound of the `MatchPattern` range.
    _MatchPattern_First,
    /// The kind of [`MatchWildcardPattern`].
    MatchWildcardPattern,
    /// The kind of [`MatchLiteralPattern`].
    MatchLiteralPattern,
    /// The kind of [`MatchUnaryPattern`].
    MatchUnaryPattern,
    /// The kind of [`MatchIdentifierPattern`].
    MatchIdentifierPattern,
    /// The kind of [`MatchBindingPattern`].
    MatchBindingPattern,
    /// The kind of [`MatchObjectPattern`].
    MatchObjectPattern,
    /// The kind of [`MatchArrayPattern`].
    MatchArrayPattern,
    /// The kind of [`MatchOrPattern`].
    MatchOrPattern,
    /// The kind of [`MatchAsPattern`].
    MatchAsPattern,
    /// The kind of [`MatchMemberPattern`].
    MatchMemberPattern,
    /// The kind of [`MatchInstancePattern`].
    MatchInstancePattern,
    /// Exclusive upper bound of the `MatchPattern` range.
    _MatchPattern_Last,
    /// The kind of [`MatchObjectPatternProperty`].
    MatchObjectPatternProperty,
    /// The kind of [`MatchInstanceObjectPattern`].
    MatchInstanceObjectPattern,
    /// The kind of [`MatchRestPattern`].
    MatchRestPattern,
    /// Exclusive lower bound of the `JSX` range.
    _JSX_First,
    /// The kind of [`JSXIdentifier`].
    JSXIdentifier,
    /// The kind of [`JSXMemberExpression`].
    JSXMemberExpression,
    /// The kind of [`JSXNamespacedName`].
    JSXNamespacedName,
    /// The kind of [`JSXEmptyExpression`].
    JSXEmptyExpression,
    /// The kind of [`JSXExpressionContainer`].
    JSXExpressionContainer,
    /// The kind of [`JSXSpreadChild`].
    JSXSpreadChild,
    /// The kind of [`JSXOpeningElement`].
    JSXOpeningElement,
    /// The kind of [`JSXClosingElement`].
    JSXClosingElement,
    /// The kind of [`JSXAttribute`].
    JSXAttribute,
    /// The kind of [`JSXSpreadAttribute`].
    JSXSpreadAttribute,
    /// The kind of [`JSXStringLiteral`].
    JSXStringLiteral,
    /// The kind of [`JSXText`].
    JSXText,
    /// The kind of [`JSXElement`].
    JSXElement,
    /// The kind of [`JSXFragment`].
    JSXFragment,
    /// The kind of [`JSXOpeningFragment`].
    JSXOpeningFragment,
    /// The kind of [`JSXClosingFragment`].
    JSXClosingFragment,
    /// Exclusive upper bound of the `JSX` range.
    _JSX_Last,
    /// Exclusive lower bound of the `Flow` range.
    _Flow_First,
    /// The kind of [`ExistsTypeAnnotation`].
    ExistsTypeAnnotation,
    /// The kind of [`EmptyTypeAnnotation`].
    EmptyTypeAnnotation,
    /// The kind of [`StringTypeAnnotation`].
    StringTypeAnnotation,
    /// The kind of [`NumberTypeAnnotation`].
    NumberTypeAnnotation,
    /// The kind of [`StringLiteralTypeAnnotation`].
    StringLiteralTypeAnnotation,
    /// The kind of [`NumberLiteralTypeAnnotation`].
    NumberLiteralTypeAnnotation,
    /// The kind of [`BigIntLiteralTypeAnnotation`].
    BigIntLiteralTypeAnnotation,
    /// The kind of [`BooleanTypeAnnotation`].
    BooleanTypeAnnotation,
    /// The kind of [`BooleanLiteralTypeAnnotation`].
    BooleanLiteralTypeAnnotation,
    /// The kind of [`NullLiteralTypeAnnotation`].
    NullLiteralTypeAnnotation,
    /// The kind of [`SymbolTypeAnnotation`].
    SymbolTypeAnnotation,
    /// The kind of [`AnyTypeAnnotation`].
    AnyTypeAnnotation,
    /// The kind of [`MixedTypeAnnotation`].
    MixedTypeAnnotation,
    /// The kind of [`BigIntTypeAnnotation`].
    BigIntTypeAnnotation,
    /// The kind of [`VoidTypeAnnotation`].
    VoidTypeAnnotation,
    /// The kind of [`NeverTypeAnnotation`].
    NeverTypeAnnotation,
    /// The kind of [`UnknownTypeAnnotation`].
    UnknownTypeAnnotation,
    /// The kind of [`UndefinedTypeAnnotation`].
    UndefinedTypeAnnotation,
    /// The kind of [`FunctionTypeAnnotation`].
    FunctionTypeAnnotation,
    /// The kind of [`HookTypeAnnotation`].
    HookTypeAnnotation,
    /// The kind of [`FunctionTypeParam`].
    FunctionTypeParam,
    /// The kind of [`ComponentTypeAnnotation`].
    ComponentTypeAnnotation,
    /// The kind of [`ComponentTypeParameter`].
    ComponentTypeParameter,
    /// The kind of [`NullableTypeAnnotation`].
    NullableTypeAnnotation,
    /// The kind of [`QualifiedTypeIdentifier`].
    QualifiedTypeIdentifier,
    /// The kind of [`TypeofTypeAnnotation`].
    TypeofTypeAnnotation,
    /// The kind of [`KeyofTypeAnnotation`].
    KeyofTypeAnnotation,
    /// The kind of [`TypeOperator`].
    TypeOperator,
    /// The kind of [`QualifiedTypeofIdentifier`].
    QualifiedTypeofIdentifier,
    /// The kind of [`TupleTypeAnnotation`].
    TupleTypeAnnotation,
    /// The kind of [`TupleTypeSpreadElement`].
    TupleTypeSpreadElement,
    /// The kind of [`TupleTypeLabeledElement`].
    TupleTypeLabeledElement,
    /// The kind of [`ArrayTypeAnnotation`].
    ArrayTypeAnnotation,
    /// The kind of [`InferTypeAnnotation`].
    InferTypeAnnotation,
    /// The kind of [`UnionTypeAnnotation`].
    UnionTypeAnnotation,
    /// The kind of [`IntersectionTypeAnnotation`].
    IntersectionTypeAnnotation,
    /// The kind of [`GenericTypeAnnotation`].
    GenericTypeAnnotation,
    /// The kind of [`IndexedAccessType`].
    IndexedAccessType,
    /// The kind of [`OptionalIndexedAccessType`].
    OptionalIndexedAccessType,
    /// The kind of [`ConditionalTypeAnnotation`].
    ConditionalTypeAnnotation,
    /// The kind of [`TypePredicate`].
    TypePredicate,
    /// The kind of [`InterfaceTypeAnnotation`].
    InterfaceTypeAnnotation,
    /// The kind of [`TypeAlias`].
    TypeAlias,
    /// The kind of [`OpaqueType`].
    OpaqueType,
    /// The kind of [`InterfaceDeclaration`].
    InterfaceDeclaration,
    /// The kind of [`DeclareTypeAlias`].
    DeclareTypeAlias,
    /// The kind of [`DeclareOpaqueType`].
    DeclareOpaqueType,
    /// The kind of [`DeclareInterface`].
    DeclareInterface,
    /// The kind of [`DeclareClass`].
    DeclareClass,
    /// The kind of [`DeclareFunction`].
    DeclareFunction,
    /// The kind of [`DeclareHook`].
    DeclareHook,
    /// The kind of [`DeclareComponent`].
    DeclareComponent,
    /// The kind of [`DeclareVariable`].
    DeclareVariable,
    /// The kind of [`DeclareEnum`].
    DeclareEnum,
    /// The kind of [`DeclareExportDeclaration`].
    DeclareExportDeclaration,
    /// The kind of [`DeclareExportAllDeclaration`].
    DeclareExportAllDeclaration,
    /// The kind of [`DeclareModule`].
    DeclareModule,
    /// The kind of [`DeclareNamespace`].
    DeclareNamespace,
    /// The kind of [`DeclareModuleExports`].
    DeclareModuleExports,
    /// The kind of [`InterfaceExtends`].
    InterfaceExtends,
    /// The kind of [`ClassImplements`].
    ClassImplements,
    /// The kind of [`TypeAnnotation`].
    TypeAnnotation,
    /// The kind of [`ObjectTypeAnnotation`].
    ObjectTypeAnnotation,
    /// The kind of [`ObjectTypeProperty`].
    ObjectTypeProperty,
    /// The kind of [`ObjectTypeSpreadProperty`].
    ObjectTypeSpreadProperty,
    /// The kind of [`ObjectTypeInternalSlot`].
    ObjectTypeInternalSlot,
    /// The kind of [`ObjectTypeCallProperty`].
    ObjectTypeCallProperty,
    /// The kind of [`ObjectTypeIndexer`].
    ObjectTypeIndexer,
    /// The kind of [`ObjectTypeMappedTypeProperty`].
    ObjectTypeMappedTypeProperty,
    /// The kind of [`Variance`].
    Variance,
    /// The kind of [`TypeParameterDeclaration`].
    TypeParameterDeclaration,
    /// The kind of [`TypeParameter`].
    TypeParameter,
    /// The kind of [`TypeParameterInstantiation`].
    TypeParameterInstantiation,
    /// The kind of [`TypeCastExpression`].
    TypeCastExpression,
    /// The kind of [`AsExpression`].
    AsExpression,
    /// The kind of [`AsConstExpression`].
    AsConstExpression,
    /// The kind of [`InferredPredicate`].
    InferredPredicate,
    /// The kind of [`DeclaredPredicate`].
    DeclaredPredicate,
    /// The kind of [`EnumDeclaration`].
    EnumDeclaration,
    /// The kind of [`EnumStringBody`].
    EnumStringBody,
    /// The kind of [`EnumNumberBody`].
    EnumNumberBody,
    /// The kind of [`EnumBigIntBody`].
    EnumBigIntBody,
    /// The kind of [`EnumBooleanBody`].
    EnumBooleanBody,
    /// The kind of [`EnumSymbolBody`].
    EnumSymbolBody,
    /// The kind of [`EnumDefaultedMember`].
    EnumDefaultedMember,
    /// The kind of [`EnumStringMember`].
    EnumStringMember,
    /// The kind of [`EnumNumberMember`].
    EnumNumberMember,
    /// The kind of [`EnumBigIntMember`].
    EnumBigIntMember,
    /// The kind of [`EnumBooleanMember`].
    EnumBooleanMember,
    /// The kind of [`ComponentParameter`].
    ComponentParameter,
    /// The kind of [`RecordDeclaration`].
    RecordDeclaration,
    /// The kind of [`RecordDeclarationImplements`].
    RecordDeclarationImplements,
    /// The kind of [`RecordDeclarationBody`].
    RecordDeclarationBody,
    /// The kind of [`RecordDeclarationProperty`].
    RecordDeclarationProperty,
    /// The kind of [`RecordDeclarationStaticProperty`].
    RecordDeclarationStaticProperty,
    /// The kind of [`RecordExpression`].
    RecordExpression,
    /// The kind of [`RecordExpressionProperties`].
    RecordExpressionProperties,
    /// Exclusive upper bound of the `Flow` range.
    _Flow_Last,
    /// Exclusive lower bound of the `TS` range.
    _TS_First,
    /// The kind of [`TSTypeAnnotation`].
    TSTypeAnnotation,
    /// The kind of [`TSAnyKeyword`].
    TSAnyKeyword,
    /// The kind of [`TSNumberKeyword`].
    TSNumberKeyword,
    /// The kind of [`TSBooleanKeyword`].
    TSBooleanKeyword,
    /// The kind of [`TSStringKeyword`].
    TSStringKeyword,
    /// The kind of [`TSSymbolKeyword`].
    TSSymbolKeyword,
    /// The kind of [`TSVoidKeyword`].
    TSVoidKeyword,
    /// The kind of [`TSUndefinedKeyword`].
    TSUndefinedKeyword,
    /// The kind of [`TSUnknownKeyword`].
    TSUnknownKeyword,
    /// The kind of [`TSNeverKeyword`].
    TSNeverKeyword,
    /// The kind of [`TSBigIntKeyword`].
    TSBigIntKeyword,
    /// The kind of [`TSThisType`].
    TSThisType,
    /// The kind of [`TSLiteralType`].
    TSLiteralType,
    /// The kind of [`TSIndexedAccessType`].
    TSIndexedAccessType,
    /// The kind of [`TSArrayType`].
    TSArrayType,
    /// The kind of [`TSTypeReference`].
    TSTypeReference,
    /// The kind of [`TSQualifiedName`].
    TSQualifiedName,
    /// The kind of [`TSFunctionType`].
    TSFunctionType,
    /// The kind of [`TSConstructorType`].
    TSConstructorType,
    /// The kind of [`TSTypePredicate`].
    TSTypePredicate,
    /// The kind of [`TSTupleType`].
    TSTupleType,
    /// The kind of [`TSTypeAssertion`].
    TSTypeAssertion,
    /// The kind of [`TSAsExpression`].
    TSAsExpression,
    /// The kind of [`TSParameterProperty`].
    TSParameterProperty,
    /// The kind of [`TSTypeAliasDeclaration`].
    TSTypeAliasDeclaration,
    /// The kind of [`TSInterfaceDeclaration`].
    TSInterfaceDeclaration,
    /// The kind of [`TSInterfaceHeritage`].
    TSInterfaceHeritage,
    /// The kind of [`TSInterfaceBody`].
    TSInterfaceBody,
    /// The kind of [`TSEnumDeclaration`].
    TSEnumDeclaration,
    /// The kind of [`TSEnumMember`].
    TSEnumMember,
    /// The kind of [`TSModuleDeclaration`].
    TSModuleDeclaration,
    /// The kind of [`TSModuleBlock`].
    TSModuleBlock,
    /// The kind of [`TSModuleMember`].
    TSModuleMember,
    /// The kind of [`TSTypeParameterDeclaration`].
    TSTypeParameterDeclaration,
    /// The kind of [`TSTypeParameter`].
    TSTypeParameter,
    /// The kind of [`TSTypeParameterInstantiation`].
    TSTypeParameterInstantiation,
    /// The kind of [`TSUnionType`].
    TSUnionType,
    /// The kind of [`TSIntersectionType`].
    TSIntersectionType,
    /// The kind of [`TSTypeQuery`].
    TSTypeQuery,
    /// The kind of [`TSConditionalType`].
    TSConditionalType,
    /// The kind of [`TSTypeLiteral`].
    TSTypeLiteral,
    /// The kind of [`TSPropertySignature`].
    TSPropertySignature,
    /// The kind of [`TSMethodSignature`].
    TSMethodSignature,
    /// The kind of [`TSIndexSignature`].
    TSIndexSignature,
    /// The kind of [`TSCallSignatureDeclaration`].
    TSCallSignatureDeclaration,
    /// The kind of [`TSModifiers`].
    TSModifiers,
    /// Exclusive upper bound of the `TS` range.
    _TS_Last,
    /// Exclusive lower bound of the `Cover` range.
    _Cover_First,
    /// The kind of [`CoverEmptyArgs`].
    CoverEmptyArgs,
    /// The kind of [`CoverTrailingComma`].
    CoverTrailingComma,
    /// The kind of [`CoverInitializer`].
    CoverInitializer,
    /// The kind of [`CoverRestElement`].
    CoverRestElement,
    /// The kind of [`CoverTypedIdentifier`].
    CoverTypedIdentifier,
    /// Exclusive upper bound of the `Cover` range.
    _Cover_Last,
    /// The kind of [`SHBuiltin`].
    SHBuiltin,
    /// The kind of [`ImplicitCheckedCast`].
    ImplicitCheckedCast,
}

/// The name of a structural child field of an AST node (used in `Path`).
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
#[allow(non_camel_case_types)]
pub enum NodeField {
    /// The `alternate` child field.
    alternate,
    /// The `argument` child field.
    argument,
    /// The `arguments` child field.
    arguments,
    /// The `attributes` child field.
    attributes,
    /// The `base` child field.
    base,
    /// The `block` child field.
    block,
    /// The `body` child field.
    body,
    /// The `bound` child field.
    bound,
    /// The `call_properties` child field.
    call_properties,
    /// The `callee` child field.
    callee,
    /// The `cases` child field.
    cases,
    /// The `check_type` child field.
    check_type,
    /// The `children` child field.
    children,
    /// The `closing_element` child field.
    closing_element,
    /// The `closing_fragment` child field.
    closing_fragment,
    /// The `consequent` child field.
    consequent,
    /// The `constraint` child field.
    constraint,
    /// The `declaration` child field.
    declaration,
    /// The `declarations` child field.
    declarations,
    /// The `decorators` child field.
    decorators,
    /// The `default` child field.
    default,
    /// The `default_value` child field.
    default_value,
    /// The `discriminant` child field.
    discriminant,
    /// The `element_type` child field.
    element_type,
    /// The `element_types` child field.
    element_types,
    /// The `elements` child field.
    elements,
    /// The `exported` child field.
    exported,
    /// The `expr_name` child field.
    expr_name,
    /// The `expression` child field.
    expression,
    /// The `expressions` child field.
    expressions,
    /// The `extends` child field.
    extends,
    /// The `extends_type` child field.
    extends_type,
    /// The `false_type` child field.
    false_type,
    /// The `finalizer` child field.
    finalizer,
    /// The `guard` child field.
    guard,
    /// The `handler` child field.
    handler,
    /// The `id` child field.
    id,
    /// The `implements` child field.
    implements,
    /// The `impltype` child field.
    impltype,
    /// The `imported` child field.
    imported,
    /// The `index_type` child field.
    index_type,
    /// The `indexers` child field.
    indexers,
    /// The `init` child field.
    init,
    /// The `initializer` child field.
    initializer,
    /// The `internal_slots` child field.
    internal_slots,
    /// The `key` child field.
    key,
    /// The `key_tparam` child field.
    key_tparam,
    /// The `label` child field.
    label,
    /// The `left` child field.
    left,
    /// The `literal` child field.
    literal,
    /// The `local` child field.
    local,
    /// The `lower_bound` child field.
    lower_bound,
    /// The `members` child field.
    members,
    /// The `meta` child field.
    meta,
    /// The `mixins` child field.
    mixins,
    /// The `name` child field.
    name,
    /// The `namespace` child field.
    namespace,
    /// The `object` child field.
    object,
    /// The `object_type` child field.
    object_type,
    /// The `opening_element` child field.
    opening_element,
    /// The `opening_fragment` child field.
    opening_fragment,
    /// The `options` child field.
    options,
    /// The `param` child field.
    param,
    /// The `parameter` child field.
    parameter,
    /// The `parameter_name` child field.
    parameter_name,
    /// The `parameters` child field.
    parameters,
    /// The `params` child field.
    params,
    /// The `pattern` child field.
    pattern,
    /// The `patterns` child field.
    patterns,
    /// The `predicate` child field.
    predicate,
    /// The `prop_type` child field.
    prop_type,
    /// The `properties` child field.
    properties,
    /// The `property` child field.
    property,
    /// The `qualification` child field.
    qualification,
    /// The `quasi` child field.
    quasi,
    /// The `quasis` child field.
    quasis,
    /// The `record_constructor` child field.
    record_constructor,
    /// The `renders_type` child field.
    renders_type,
    /// The `rest` child field.
    rest,
    /// The `return_type` child field.
    return_type,
    /// The `right` child field.
    right,
    /// The `source` child field.
    source,
    /// The `source_type` child field.
    source_type,
    /// The `specifiers` child field.
    specifiers,
    /// The `super_class` child field.
    super_class,
    /// The `super_type_arguments` child field.
    super_type_arguments,
    /// The `supertype` child field.
    supertype,
    /// The `tag` child field.
    tag,
    /// The `target` child field.
    target,
    /// The `target_constructor` child field.
    target_constructor,
    /// The `test` child field.
    test,
    /// The `this` child field.
    this,
    /// The `true_type` child field.
    true_type,
    /// The `ts_modifiers` child field.
    ts_modifiers,
    /// The `type_annotation` child field.
    type_annotation,
    /// The `type_arguments` child field.
    type_arguments,
    /// The `type_name` child field.
    type_name,
    /// The `type_parameter` child field.
    type_parameter,
    /// The `type_parameters` child field.
    type_parameters,
    /// The `types` child field.
    types,
    /// The `update` child field.
    update,
    /// The `upper_bound` child field.
    upper_bound,
    /// The `value` child field.
    value,
    /// The `variance` child field.
    variance,
}

/// The `Empty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct Empty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> Empty<'gc> {
    /// Build `Empty` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        Empty {
            metadata,
        }
    }
}

/// The `Metadata` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct Metadata<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> Metadata<'gc> {
    /// Build `Metadata` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        Metadata {
            metadata,
        }
    }
}

/// The `Program` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct Program<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `body` property.
    pub body: NodeList<'gc>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` for this function.
    pub sem_info: Cell<Option<SemaId>>,
    /// Sema: strict-mode state of this function.
    pub strictness: Cell<Strictness>,
    /// Whether this function is a method definition (getters and setters
    /// included) rather than a `function`. Used for lazy reparsing.
    pub is_method_definition: Cell<bool>,
    /// Decorations attached to this function by `Hermes.decorate(...)`
    /// calls in typed mode; each entry wraps a decoration expression.
    pub decorations: Cell<NodeList<'gc>>,
    /// An always-empty parameter list, for uniformity with functions.
    pub dummy_param_list: Cell<NodeList<'gc>>,
}
impl<'gc> Program<'gc> {
    /// Build `Program` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        body: NodeList<'gc>,
    ) -> Self {
        Program {
            metadata,
            body,
            scope: Cell::new(None),
            sem_info: Cell::new(None),
            strictness: Cell::new(Strictness::NotSet),
            is_method_definition: Cell::new(false),
            decorations: Cell::new(NodeList::empty()),
            dummy_param_list: Cell::new(NodeList::empty()),
        }
    }
}

/// The `FunctionExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct FunctionExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: Option<&'gc Node<'gc>>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `returnType` property.
    pub return_type: Option<&'gc Node<'gc>>,
    /// ESTree `predicate` property.
    pub predicate: Option<&'gc Node<'gc>>,
    /// ESTree `generator` property.
    pub generator: Cell<bool>,
    /// ESTree `async` property.
    pub r#async: Cell<bool>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` for this function.
    pub sem_info: Cell<Option<SemaId>>,
    /// Sema: strict-mode state of this function.
    pub strictness: Cell<Strictness>,
    /// Whether this function is a method definition (getters and setters
    /// included) rather than a `function`. Used for lazy reparsing.
    pub is_method_definition: Cell<bool>,
    /// Decorations attached to this function by `Hermes.decorate(...)`
    /// calls in typed mode; each entry wraps a decoration expression.
    pub decorations: Cell<NodeList<'gc>>,
}
impl<'gc> FunctionExpression<'gc> {
    /// Build `FunctionExpression` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: Option<&'gc Node<'gc>>,
        params: NodeList<'gc>,
        body: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        return_type: Option<&'gc Node<'gc>>,
        predicate: Option<&'gc Node<'gc>>,
        generator: bool,
        r#async: bool,
    ) -> Self {
        FunctionExpression {
            metadata,
            id,
            params,
            body,
            type_parameters,
            return_type,
            predicate,
            generator: Cell::new(generator),
            r#async: Cell::new(r#async),
            scope: Cell::new(None),
            sem_info: Cell::new(None),
            strictness: Cell::new(Strictness::NotSet),
            is_method_definition: Cell::new(false),
            decorations: Cell::new(NodeList::empty()),
        }
    }
}

/// The `ArrowFunctionExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ArrowFunctionExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `returnType` property.
    pub return_type: Option<&'gc Node<'gc>>,
    /// ESTree `predicate` property.
    pub predicate: Option<&'gc Node<'gc>>,
    /// ESTree `expression` property.
    pub expression: Cell<bool>,
    /// ESTree `async` property.
    pub r#async: Cell<bool>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` for this function.
    pub sem_info: Cell<Option<SemaId>>,
    /// Sema: strict-mode state of this function.
    pub strictness: Cell<Strictness>,
    /// Whether this function is a method definition (getters and setters
    /// included) rather than a `function`. Used for lazy reparsing.
    pub is_method_definition: Cell<bool>,
    /// Decorations attached to this function by `Hermes.decorate(...)`
    /// calls in typed mode; each entry wraps a decoration expression.
    pub decorations: Cell<NodeList<'gc>>,
}
impl<'gc> ArrowFunctionExpression<'gc> {
    /// Build `ArrowFunctionExpression` from its metadata and `ESTree.def`
    /// fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
        body: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        return_type: Option<&'gc Node<'gc>>,
        predicate: Option<&'gc Node<'gc>>,
        expression: bool,
        r#async: bool,
    ) -> Self {
        ArrowFunctionExpression {
            metadata,
            params,
            body,
            type_parameters,
            return_type,
            predicate,
            expression: Cell::new(expression),
            r#async: Cell::new(r#async),
            scope: Cell::new(None),
            sem_info: Cell::new(None),
            strictness: Cell::new(Strictness::NotSet),
            is_method_definition: Cell::new(false),
            decorations: Cell::new(NodeList::empty()),
        }
    }
}

/// The `FunctionDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct FunctionDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: Option<&'gc Node<'gc>>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `returnType` property.
    pub return_type: Option<&'gc Node<'gc>>,
    /// ESTree `predicate` property.
    pub predicate: Option<&'gc Node<'gc>>,
    /// ESTree `generator` property.
    pub generator: Cell<bool>,
    /// ESTree `async` property.
    pub r#async: Cell<bool>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` for this function.
    pub sem_info: Cell<Option<SemaId>>,
    /// Sema: strict-mode state of this function.
    pub strictness: Cell<Strictness>,
    /// Whether this function is a method definition (getters and setters
    /// included) rather than a `function`. Used for lazy reparsing.
    pub is_method_definition: Cell<bool>,
    /// Decorations attached to this function by `Hermes.decorate(...)`
    /// calls in typed mode; each entry wraps a decoration expression.
    pub decorations: Cell<NodeList<'gc>>,
}
impl<'gc> FunctionDeclaration<'gc> {
    /// Build `FunctionDeclaration` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: Option<&'gc Node<'gc>>,
        params: NodeList<'gc>,
        body: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        return_type: Option<&'gc Node<'gc>>,
        predicate: Option<&'gc Node<'gc>>,
        generator: bool,
        r#async: bool,
    ) -> Self {
        FunctionDeclaration {
            metadata,
            id,
            params,
            body,
            type_parameters,
            return_type,
            predicate,
            generator: Cell::new(generator),
            r#async: Cell::new(r#async),
            scope: Cell::new(None),
            sem_info: Cell::new(None),
            strictness: Cell::new(Strictness::NotSet),
            is_method_definition: Cell::new(false),
            decorations: Cell::new(NodeList::empty()),
        }
    }
}

/// The `ComponentDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ComponentDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `rendersType` property.
    pub renders_type: Option<&'gc Node<'gc>>,
    /// ESTree `async` property.
    pub r#async: Cell<bool>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` for this function.
    pub sem_info: Cell<Option<SemaId>>,
    /// Sema: strict-mode state of this function.
    pub strictness: Cell<Strictness>,
    /// Whether this function is a method definition (getters and setters
    /// included) rather than a `function`. Used for lazy reparsing.
    pub is_method_definition: Cell<bool>,
    /// Decorations attached to this function by `Hermes.decorate(...)`
    /// calls in typed mode; each entry wraps a decoration expression.
    pub decorations: Cell<NodeList<'gc>>,
}
impl<'gc> ComponentDeclaration<'gc> {
    /// Build `ComponentDeclaration` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        params: NodeList<'gc>,
        body: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        renders_type: Option<&'gc Node<'gc>>,
        r#async: bool,
    ) -> Self {
        ComponentDeclaration {
            metadata,
            id,
            params,
            body,
            type_parameters,
            renders_type,
            r#async: Cell::new(r#async),
            scope: Cell::new(None),
            sem_info: Cell::new(None),
            strictness: Cell::new(Strictness::NotSet),
            is_method_definition: Cell::new(false),
            decorations: Cell::new(NodeList::empty()),
        }
    }
}

/// The `HookDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct HookDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `returnType` property.
    pub return_type: Option<&'gc Node<'gc>>,
    /// ESTree `async` property.
    pub r#async: Cell<bool>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` for this function.
    pub sem_info: Cell<Option<SemaId>>,
    /// Sema: strict-mode state of this function.
    pub strictness: Cell<Strictness>,
    /// Whether this function is a method definition (getters and setters
    /// included) rather than a `function`. Used for lazy reparsing.
    pub is_method_definition: Cell<bool>,
    /// Decorations attached to this function by `Hermes.decorate(...)`
    /// calls in typed mode; each entry wraps a decoration expression.
    pub decorations: Cell<NodeList<'gc>>,
}
impl<'gc> HookDeclaration<'gc> {
    /// Build `HookDeclaration` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        params: NodeList<'gc>,
        body: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        return_type: Option<&'gc Node<'gc>>,
        r#async: bool,
    ) -> Self {
        HookDeclaration {
            metadata,
            id,
            params,
            body,
            type_parameters,
            return_type,
            r#async: Cell::new(r#async),
            scope: Cell::new(None),
            sem_info: Cell::new(None),
            strictness: Cell::new(Strictness::NotSet),
            is_method_definition: Cell::new(false),
            decorations: Cell::new(NodeList::empty()),
        }
    }
}

/// The `MatchStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
    /// ESTree `cases` property.
    pub cases: NodeList<'gc>,
}
impl<'gc> MatchStatement<'gc> {
    /// Build `MatchStatement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
        cases: NodeList<'gc>,
    ) -> Self {
        MatchStatement {
            metadata,
            argument,
            cases,
        }
    }
}

/// The `WhileStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct WhileStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `test` property.
    pub test: &'gc Node<'gc>,
    /// Sema: label index; `INVALID_LABEL` until set.
    pub label_index: Cell<u32>,
}
impl<'gc> WhileStatement<'gc> {
    /// Build `WhileStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        body: &'gc Node<'gc>,
        test: &'gc Node<'gc>,
    ) -> Self {
        WhileStatement {
            metadata,
            body,
            test,
            label_index: Cell::new(INVALID_LABEL),
        }
    }
}

/// The `DoWhileStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DoWhileStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `test` property.
    pub test: &'gc Node<'gc>,
    /// Sema: label index; `INVALID_LABEL` until set.
    pub label_index: Cell<u32>,
}
impl<'gc> DoWhileStatement<'gc> {
    /// Build `DoWhileStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        body: &'gc Node<'gc>,
        test: &'gc Node<'gc>,
    ) -> Self {
        DoWhileStatement {
            metadata,
            body,
            test,
            label_index: Cell::new(INVALID_LABEL),
        }
    }
}

/// The `ForInStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ForInStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `left` property.
    pub left: &'gc Node<'gc>,
    /// ESTree `right` property.
    pub right: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// Sema: label index; `INVALID_LABEL` until set.
    pub label_index: Cell<u32>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
}
impl<'gc> ForInStatement<'gc> {
    /// Build `ForInStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        left: &'gc Node<'gc>,
        right: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        ForInStatement {
            metadata,
            left,
            right,
            body,
            label_index: Cell::new(INVALID_LABEL),
            scope: Cell::new(None),
        }
    }
}

/// The `ForOfStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ForOfStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `left` property.
    pub left: &'gc Node<'gc>,
    /// ESTree `right` property.
    pub right: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `await` property.
    pub r#await: Cell<bool>,
    /// Sema: label index; `INVALID_LABEL` until set.
    pub label_index: Cell<u32>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
}
impl<'gc> ForOfStatement<'gc> {
    /// Build `ForOfStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        left: &'gc Node<'gc>,
        right: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
        r#await: bool,
    ) -> Self {
        ForOfStatement {
            metadata,
            left,
            right,
            body,
            r#await: Cell::new(r#await),
            label_index: Cell::new(INVALID_LABEL),
            scope: Cell::new(None),
        }
    }
}

/// The `ForStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ForStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `init` property.
    pub init: Option<&'gc Node<'gc>>,
    /// ESTree `test` property.
    pub test: Option<&'gc Node<'gc>>,
    /// ESTree `update` property.
    pub update: Option<&'gc Node<'gc>>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// Sema: label index; `INVALID_LABEL` until set.
    pub label_index: Cell<u32>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
}
impl<'gc> ForStatement<'gc> {
    /// Build `ForStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        init: Option<&'gc Node<'gc>>,
        test: Option<&'gc Node<'gc>>,
        update: Option<&'gc Node<'gc>>,
        body: &'gc Node<'gc>,
    ) -> Self {
        ForStatement {
            metadata,
            init,
            test,
            update,
            body,
            label_index: Cell::new(INVALID_LABEL),
            scope: Cell::new(None),
        }
    }
}

/// The `DebuggerStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DebuggerStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> DebuggerStatement<'gc> {
    /// Build `DebuggerStatement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        DebuggerStatement {
            metadata,
        }
    }
}

/// The `EmptyStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EmptyStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> EmptyStatement<'gc> {
    /// Build `EmptyStatement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        EmptyStatement {
            metadata,
        }
    }
}

/// The `BlockStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct BlockStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `body` property.
    pub body: NodeList<'gc>,
    /// ESTree `implicit` property.
    pub implicit: Cell<bool>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// The source buffer id in which this block was found.
    pub buffer_id: Cell<u32>,
    /// True if this is a function body pruned while pre-parsing.
    pub is_lazy_function_body: Cell<bool>,
    /// For a lazy block, the `Yield` param to restore when parsed eagerly.
    pub param_yield: Cell<bool>,
    /// For a lazy block, the `Await` param to restore when parsed eagerly.
    pub param_await: Cell<bool>,
    /// Whether this function contains an arrow function. Read by lazy
    /// compilation to populate the `FunctionInfo`.
    pub contains_arrow_functions: Cell<bool>,
    /// Conservative estimate of whether an arrow function here may use
    /// `arguments`, so a non-arrow function must eagerly capture it.
    pub may_contain_arrow_functions_using_arguments: Cell<bool>,
}
impl<'gc> BlockStatement<'gc> {
    /// Build `BlockStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        body: NodeList<'gc>,
        implicit: bool,
    ) -> Self {
        BlockStatement {
            metadata,
            body,
            implicit: Cell::new(implicit),
            scope: Cell::new(None),
            buffer_id: Cell::new(0),
            is_lazy_function_body: Cell::new(false),
            param_yield: Cell::new(false),
            param_await: Cell::new(false),
            contains_arrow_functions: Cell::new(false),
            may_contain_arrow_functions_using_arguments: Cell::new(false),
        }
    }
}

/// The `StaticBlock` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct StaticBlock<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `body` property.
    pub body: NodeList<'gc>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` for this static block.
    pub function_info: Cell<Option<SemaId>>,
}
impl<'gc> StaticBlock<'gc> {
    /// Build `StaticBlock` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        body: NodeList<'gc>,
    ) -> Self {
        StaticBlock {
            metadata,
            body,
            scope: Cell::new(None),
            function_info: Cell::new(None),
        }
    }
}

/// The `BreakStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct BreakStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `label` property.
    pub label: Option<&'gc Node<'gc>>,
    /// Sema: label index; `INVALID_LABEL` until set.
    pub label_index: Cell<u32>,
}
impl<'gc> BreakStatement<'gc> {
    /// Build `BreakStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        label: Option<&'gc Node<'gc>>,
    ) -> Self {
        BreakStatement {
            metadata,
            label,
            label_index: Cell::new(INVALID_LABEL),
        }
    }
}

/// The `ContinueStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ContinueStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `label` property.
    pub label: Option<&'gc Node<'gc>>,
    /// Sema: label index; `INVALID_LABEL` until set.
    pub label_index: Cell<u32>,
}
impl<'gc> ContinueStatement<'gc> {
    /// Build `ContinueStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        label: Option<&'gc Node<'gc>>,
    ) -> Self {
        ContinueStatement {
            metadata,
            label,
            label_index: Cell::new(INVALID_LABEL),
        }
    }
}

/// The `ThrowStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ThrowStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
}
impl<'gc> ThrowStatement<'gc> {
    /// Build `ThrowStatement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
    ) -> Self {
        ThrowStatement {
            metadata,
            argument,
        }
    }
}

/// The `ReturnStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ReturnStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: Option<&'gc Node<'gc>>,
}
impl<'gc> ReturnStatement<'gc> {
    /// Build `ReturnStatement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: Option<&'gc Node<'gc>>,
    ) -> Self {
        ReturnStatement {
            metadata,
            argument,
        }
    }
}

/// The `WithStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct WithStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `object` property.
    pub object: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> WithStatement<'gc> {
    /// Build `WithStatement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        object: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        WithStatement {
            metadata,
            object,
            body,
        }
    }
}

/// The `SwitchStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct SwitchStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `discriminant` property.
    pub discriminant: &'gc Node<'gc>,
    /// ESTree `cases` property.
    pub cases: NodeList<'gc>,
    /// Sema: label index; `INVALID_LABEL` until set.
    pub label_index: Cell<u32>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
}
impl<'gc> SwitchStatement<'gc> {
    /// Build `SwitchStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        discriminant: &'gc Node<'gc>,
        cases: NodeList<'gc>,
    ) -> Self {
        SwitchStatement {
            metadata,
            discriminant,
            cases,
            label_index: Cell::new(INVALID_LABEL),
            scope: Cell::new(None),
        }
    }
}

/// The `LabeledStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct LabeledStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `label` property.
    pub label: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// Sema: label index; `INVALID_LABEL` until set.
    pub label_index: Cell<u32>,
}
impl<'gc> LabeledStatement<'gc> {
    /// Build `LabeledStatement` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        label: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        LabeledStatement {
            metadata,
            label,
            body,
            label_index: Cell::new(INVALID_LABEL),
        }
    }
}

/// The `ExpressionStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ExpressionStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
    /// ESTree `directive` property.
    pub directive: Cell<NodeString>,
}
impl<'gc> ExpressionStatement<'gc> {
    /// Build `ExpressionStatement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expression: &'gc Node<'gc>,
        directive: NodeString,
    ) -> Self {
        ExpressionStatement {
            metadata,
            expression,
            directive: Cell::new(directive),
        }
    }
    /// The `directive` string value as UTF-8, or `None` if it has no UTF-8
    /// form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `directive_str`: an unrepresentable
    /// identifier means something is broken, but an unrepresentable string
    /// literal is legal JS, and a codegen or refactoring tool that let U+FFFD
    /// be substituted here would silently rewrite the user's program. Reach for
    /// [`Self::directive_str_lossy`] only when a best-effort rendering is what
    /// you want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_directive_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.directive.get())
    }
    /// The `directive` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_directive_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn directive_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.directive.get())
    }
}

/// The `TryStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TryStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `block` property.
    pub block: &'gc Node<'gc>,
    /// ESTree `handler` property.
    pub handler: Option<&'gc Node<'gc>>,
    /// ESTree `finalizer` property.
    pub finalizer: Option<&'gc Node<'gc>>,
}
impl<'gc> TryStatement<'gc> {
    /// Build `TryStatement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        block: &'gc Node<'gc>,
        handler: Option<&'gc Node<'gc>>,
        finalizer: Option<&'gc Node<'gc>>,
    ) -> Self {
        TryStatement {
            metadata,
            block,
            handler,
            finalizer,
        }
    }
}

/// The `IfStatement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct IfStatement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `test` property.
    pub test: &'gc Node<'gc>,
    /// ESTree `consequent` property.
    pub consequent: &'gc Node<'gc>,
    /// ESTree `alternate` property.
    pub alternate: Option<&'gc Node<'gc>>,
}
impl<'gc> IfStatement<'gc> {
    /// Build `IfStatement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        test: &'gc Node<'gc>,
        consequent: &'gc Node<'gc>,
        alternate: Option<&'gc Node<'gc>>,
    ) -> Self {
        IfStatement {
            metadata,
            test,
            consequent,
            alternate,
        }
    }
}

/// The `NullLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct NullLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> NullLiteral<'gc> {
    /// Build `NullLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        NullLiteral {
            metadata,
        }
    }
}

/// The `BooleanLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct BooleanLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: Cell<bool>,
}
impl<'gc> BooleanLiteral<'gc> {
    /// Build `BooleanLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: bool,
    ) -> Self {
        BooleanLiteral {
            metadata,
            value: Cell::new(value),
        }
    }
}

/// The `StringLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct StringLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: Cell<NodeString>,
}
impl<'gc> StringLiteral<'gc> {
    /// Build `StringLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: NodeString,
    ) -> Self {
        StringLiteral {
            metadata,
            value: Cell::new(value),
        }
    }
    /// The `value` string value as UTF-8, or `None` if it has no UTF-8 form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `value_str`: an unrepresentable
    /// identifier means something is broken, but an unrepresentable string
    /// literal is legal JS, and a codegen or refactoring tool that let U+FFFD
    /// be substituted here would silently rewrite the user's program. Reach for
    /// [`Self::value_str_lossy`] only when a best-effort rendering is what you
    /// want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_value_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.value.get())
    }
    /// The `value` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_value_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn value_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.value.get())
    }
}

/// The `NumericLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct NumericLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: Cell<f64>,
}
impl<'gc> NumericLiteral<'gc> {
    /// Build `NumericLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: f64,
    ) -> Self {
        NumericLiteral {
            metadata,
            value: Cell::new(value),
        }
    }
}

/// The `RegExpLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct RegExpLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `pattern` property.
    pub pattern: Cell<NodeLabel>,
    /// ESTree `flags` property.
    pub flags: Cell<NodeLabel>,
}
impl<'gc> RegExpLiteral<'gc> {
    /// Build `RegExpLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        pattern: NodeLabel,
        flags: NodeLabel,
    ) -> Self {
        RegExpLiteral {
            metadata,
            pattern: Cell::new(pattern),
            flags: Cell::new(flags),
        }
    }
    /// The `pattern` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn pattern_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.pattern.get())
    }
    /// The `flags` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn flags_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.flags.get())
    }
}

/// The `BigIntLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct BigIntLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `bigint` property.
    pub bigint: Cell<NodeLabel>,
}
impl<'gc> BigIntLiteral<'gc> {
    /// Build `BigIntLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        bigint: NodeLabel,
    ) -> Self {
        BigIntLiteral {
            metadata,
            bigint: Cell::new(bigint),
        }
    }
    /// The `bigint` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn bigint_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.bigint.get())
    }
}

/// The `ThisExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ThisExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> ThisExpression<'gc> {
    /// Build `ThisExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        ThisExpression {
            metadata,
        }
    }
}

/// The `Super` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct Super<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> Super<'gc> {
    /// Build `Super` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        Super {
            metadata,
        }
    }
}

/// The `SequenceExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct SequenceExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expressions` property.
    pub expressions: NodeList<'gc>,
}
impl<'gc> SequenceExpression<'gc> {
    /// Build `SequenceExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expressions: NodeList<'gc>,
    ) -> Self {
        SequenceExpression {
            metadata,
            expressions,
        }
    }
}

/// The `ObjectExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ObjectExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `properties` property.
    pub properties: NodeList<'gc>,
}
impl<'gc> ObjectExpression<'gc> {
    /// Build `ObjectExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        properties: NodeList<'gc>,
    ) -> Self {
        ObjectExpression {
            metadata,
            properties,
        }
    }
}

/// The `ArrayExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ArrayExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `elements` property.
    pub elements: NodeList<'gc>,
    /// ESTree `trailingComma` property.
    pub trailing_comma: Cell<bool>,
}
impl<'gc> ArrayExpression<'gc> {
    /// Build `ArrayExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        elements: NodeList<'gc>,
        trailing_comma: bool,
    ) -> Self {
        ArrayExpression {
            metadata,
            elements,
            trailing_comma: Cell::new(trailing_comma),
        }
    }
}

/// The `SpreadElement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct SpreadElement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
}
impl<'gc> SpreadElement<'gc> {
    /// Build `SpreadElement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
    ) -> Self {
        SpreadElement {
            metadata,
            argument,
        }
    }
}

/// The `NewExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct NewExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `callee` property.
    pub callee: &'gc Node<'gc>,
    /// ESTree `typeArguments` property.
    pub type_arguments: Option<&'gc Node<'gc>>,
    /// ESTree `arguments` property.
    pub arguments: NodeList<'gc>,
}
impl<'gc> NewExpression<'gc> {
    /// Build `NewExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        callee: &'gc Node<'gc>,
        type_arguments: Option<&'gc Node<'gc>>,
        arguments: NodeList<'gc>,
    ) -> Self {
        NewExpression {
            metadata,
            callee,
            type_arguments,
            arguments,
        }
    }
}

/// The `YieldExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct YieldExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: Option<&'gc Node<'gc>>,
    /// ESTree `delegate` property.
    pub delegate: Cell<bool>,
}
impl<'gc> YieldExpression<'gc> {
    /// Build `YieldExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: Option<&'gc Node<'gc>>,
        delegate: bool,
    ) -> Self {
        YieldExpression {
            metadata,
            argument,
            delegate: Cell::new(delegate),
        }
    }
}

/// The `AwaitExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct AwaitExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
}
impl<'gc> AwaitExpression<'gc> {
    /// Build `AwaitExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
    ) -> Self {
        AwaitExpression {
            metadata,
            argument,
        }
    }
}

/// The `ImportExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ImportExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `source` property.
    pub source: &'gc Node<'gc>,
    /// ESTree `options` property.
    pub options: Option<&'gc Node<'gc>>,
}
impl<'gc> ImportExpression<'gc> {
    /// Build `ImportExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        source: &'gc Node<'gc>,
        options: Option<&'gc Node<'gc>>,
    ) -> Self {
        ImportExpression {
            metadata,
            source,
            options,
        }
    }
}

/// The `CallExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct CallExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `callee` property.
    pub callee: &'gc Node<'gc>,
    /// ESTree `typeArguments` property.
    pub type_arguments: Option<&'gc Node<'gc>>,
    /// ESTree `arguments` property.
    pub arguments: NodeList<'gc>,
}
impl<'gc> CallExpression<'gc> {
    /// Build `CallExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        callee: &'gc Node<'gc>,
        type_arguments: Option<&'gc Node<'gc>>,
        arguments: NodeList<'gc>,
    ) -> Self {
        CallExpression {
            metadata,
            callee,
            type_arguments,
            arguments,
        }
    }
}

/// The `OptionalCallExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct OptionalCallExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `callee` property.
    pub callee: &'gc Node<'gc>,
    /// ESTree `typeArguments` property.
    pub type_arguments: Option<&'gc Node<'gc>>,
    /// ESTree `arguments` property.
    pub arguments: NodeList<'gc>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
}
impl<'gc> OptionalCallExpression<'gc> {
    /// Build `OptionalCallExpression` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        callee: &'gc Node<'gc>,
        type_arguments: Option<&'gc Node<'gc>>,
        arguments: NodeList<'gc>,
        optional: bool,
    ) -> Self {
        OptionalCallExpression {
            metadata,
            callee,
            type_arguments,
            arguments,
            optional: Cell::new(optional),
        }
    }
}

/// The `AssignmentExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct AssignmentExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `operator` property.
    pub operator: Cell<NodeLabel>,
    /// ESTree `left` property.
    pub left: &'gc Node<'gc>,
    /// ESTree `right` property.
    pub right: &'gc Node<'gc>,
}
impl<'gc> AssignmentExpression<'gc> {
    /// Build `AssignmentExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        operator: NodeLabel,
        left: &'gc Node<'gc>,
        right: &'gc Node<'gc>,
    ) -> Self {
        AssignmentExpression {
            metadata,
            operator: Cell::new(operator),
            left,
            right,
        }
    }
    /// The `operator` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn operator_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.operator.get())
    }
}

/// The `UnaryExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct UnaryExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `operator` property.
    pub operator: Cell<NodeLabel>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
    /// ESTree `prefix` property.
    pub prefix: Cell<bool>,
}
impl<'gc> UnaryExpression<'gc> {
    /// Build `UnaryExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        operator: NodeLabel,
        argument: &'gc Node<'gc>,
        prefix: bool,
    ) -> Self {
        UnaryExpression {
            metadata,
            operator: Cell::new(operator),
            argument,
            prefix: Cell::new(prefix),
        }
    }
    /// The `operator` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn operator_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.operator.get())
    }
}

/// The `UpdateExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct UpdateExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `operator` property.
    pub operator: Cell<NodeLabel>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
    /// ESTree `prefix` property.
    pub prefix: Cell<bool>,
}
impl<'gc> UpdateExpression<'gc> {
    /// Build `UpdateExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        operator: NodeLabel,
        argument: &'gc Node<'gc>,
        prefix: bool,
    ) -> Self {
        UpdateExpression {
            metadata,
            operator: Cell::new(operator),
            argument,
            prefix: Cell::new(prefix),
        }
    }
    /// The `operator` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn operator_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.operator.get())
    }
}

/// The `MemberExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MemberExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `object` property.
    pub object: &'gc Node<'gc>,
    /// ESTree `property` property.
    pub property: &'gc Node<'gc>,
    /// ESTree `computed` property.
    pub computed: Cell<bool>,
}
impl<'gc> MemberExpression<'gc> {
    /// Build `MemberExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        object: &'gc Node<'gc>,
        property: &'gc Node<'gc>,
        computed: bool,
    ) -> Self {
        MemberExpression {
            metadata,
            object,
            property,
            computed: Cell::new(computed),
        }
    }
}

/// The `OptionalMemberExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct OptionalMemberExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `object` property.
    pub object: &'gc Node<'gc>,
    /// ESTree `property` property.
    pub property: &'gc Node<'gc>,
    /// ESTree `computed` property.
    pub computed: Cell<bool>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
}
impl<'gc> OptionalMemberExpression<'gc> {
    /// Build `OptionalMemberExpression` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        object: &'gc Node<'gc>,
        property: &'gc Node<'gc>,
        computed: bool,
        optional: bool,
    ) -> Self {
        OptionalMemberExpression {
            metadata,
            object,
            property,
            computed: Cell::new(computed),
            optional: Cell::new(optional),
        }
    }
}

/// The `LogicalExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct LogicalExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `left` property.
    pub left: &'gc Node<'gc>,
    /// ESTree `right` property.
    pub right: &'gc Node<'gc>,
    /// ESTree `operator` property.
    pub operator: Cell<NodeLabel>,
}
impl<'gc> LogicalExpression<'gc> {
    /// Build `LogicalExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        left: &'gc Node<'gc>,
        right: &'gc Node<'gc>,
        operator: NodeLabel,
    ) -> Self {
        LogicalExpression {
            metadata,
            left,
            right,
            operator: Cell::new(operator),
        }
    }
    /// The `operator` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn operator_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.operator.get())
    }
}

/// The `ConditionalExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ConditionalExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `test` property.
    pub test: &'gc Node<'gc>,
    /// ESTree `alternate` property.
    pub alternate: &'gc Node<'gc>,
    /// ESTree `consequent` property.
    pub consequent: &'gc Node<'gc>,
}
impl<'gc> ConditionalExpression<'gc> {
    /// Build `ConditionalExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        test: &'gc Node<'gc>,
        alternate: &'gc Node<'gc>,
        consequent: &'gc Node<'gc>,
    ) -> Self {
        ConditionalExpression {
            metadata,
            test,
            alternate,
            consequent,
        }
    }
}

/// The `BinaryExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct BinaryExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `left` property.
    pub left: &'gc Node<'gc>,
    /// ESTree `right` property.
    pub right: &'gc Node<'gc>,
    /// ESTree `operator` property.
    pub operator: Cell<NodeLabel>,
}
impl<'gc> BinaryExpression<'gc> {
    /// Build `BinaryExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        left: &'gc Node<'gc>,
        right: &'gc Node<'gc>,
        operator: NodeLabel,
    ) -> Self {
        BinaryExpression {
            metadata,
            left,
            right,
            operator: Cell::new(operator),
        }
    }
    /// The `operator` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn operator_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.operator.get())
    }
}

/// The `Directive` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct Directive<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
}
impl<'gc> Directive<'gc> {
    /// Build `Directive` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: &'gc Node<'gc>,
    ) -> Self {
        Directive {
            metadata,
            value,
        }
    }
}

/// The `DirectiveLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DirectiveLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: Cell<NodeString>,
}
impl<'gc> DirectiveLiteral<'gc> {
    /// Build `DirectiveLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: NodeString,
    ) -> Self {
        DirectiveLiteral {
            metadata,
            value: Cell::new(value),
        }
    }
    /// The `value` string value as UTF-8, or `None` if it has no UTF-8 form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `value_str`: an unrepresentable
    /// identifier means something is broken, but an unrepresentable string
    /// literal is legal JS, and a codegen or refactoring tool that let U+FFFD
    /// be substituted here would silently rewrite the user's program. Reach for
    /// [`Self::value_str_lossy`] only when a best-effort rendering is what you
    /// want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_value_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.value.get())
    }
    /// The `value` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_value_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn value_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.value.get())
    }
}

/// The `Identifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct Identifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: Cell<NodeLabel>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: Option<&'gc Node<'gc>>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
    /// Sema: unresolvable because of an enclosing `eval` or `with`.
    pub unresolvable: Cell<bool>,
    /// Sema: how to read `decl` — the `BitHave*` bits of `ESTree.h`'s
    /// `IdentifierDecoration`.
    pub decl_state: Cell<u8>,
    /// Sema: the declaration this identifier resolves to; `None` until a
    /// resolution is recorded.
    pub decl: Cell<Option<SemaId>>,
}
impl<'gc> Identifier<'gc> {
    /// Build `Identifier` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: NodeLabel,
        type_annotation: Option<&'gc Node<'gc>>,
        optional: bool,
    ) -> Self {
        Identifier {
            metadata,
            name: Cell::new(name),
            type_annotation,
            optional: Cell::new(optional),
            unresolvable: Cell::new(false),
            decl_state: Cell::new(0),
            decl: Cell::new(None),
        }
    }
    /// The `name` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn name_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.name.get())
    }
}

/// The `PrivateName` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct PrivateName<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
}
impl<'gc> PrivateName<'gc> {
    /// Build `PrivateName` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
    ) -> Self {
        PrivateName {
            metadata,
            id,
        }
    }
}

/// The `MetaProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MetaProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `meta` property.
    pub meta: &'gc Node<'gc>,
    /// ESTree `property` property.
    pub property: &'gc Node<'gc>,
}
impl<'gc> MetaProperty<'gc> {
    /// Build `MetaProperty` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        meta: &'gc Node<'gc>,
        property: &'gc Node<'gc>,
    ) -> Self {
        MetaProperty {
            metadata,
            meta,
            property,
        }
    }
}

/// The `SwitchCase` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct SwitchCase<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `test` property.
    pub test: Option<&'gc Node<'gc>>,
    /// ESTree `consequent` property.
    pub consequent: NodeList<'gc>,
}
impl<'gc> SwitchCase<'gc> {
    /// Build `SwitchCase` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        test: Option<&'gc Node<'gc>>,
        consequent: NodeList<'gc>,
    ) -> Self {
        SwitchCase {
            metadata,
            test,
            consequent,
        }
    }
}

/// The `CatchClause` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct CatchClause<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `param` property.
    pub param: Option<&'gc Node<'gc>>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
}
impl<'gc> CatchClause<'gc> {
    /// Build `CatchClause` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        param: Option<&'gc Node<'gc>>,
        body: &'gc Node<'gc>,
    ) -> Self {
        CatchClause {
            metadata,
            param,
            body,
            scope: Cell::new(None),
        }
    }
}

/// The `VariableDeclarator` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct VariableDeclarator<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `init` property.
    pub init: Option<&'gc Node<'gc>>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
}
impl<'gc> VariableDeclarator<'gc> {
    /// Build `VariableDeclarator` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        init: Option<&'gc Node<'gc>>,
        id: &'gc Node<'gc>,
    ) -> Self {
        VariableDeclarator {
            metadata,
            init,
            id,
        }
    }
}

/// The `VariableDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct VariableDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `kind` property.
    pub kind: Cell<NodeLabel>,
    /// ESTree `declarations` property.
    pub declarations: NodeList<'gc>,
}
impl<'gc> VariableDeclaration<'gc> {
    /// Build `VariableDeclaration` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        kind: NodeLabel,
        declarations: NodeList<'gc>,
    ) -> Self {
        VariableDeclaration {
            metadata,
            kind: Cell::new(kind),
            declarations,
        }
    }
    /// The `kind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.kind.get())
    }
}

/// The `TemplateLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TemplateLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `quasis` property.
    pub quasis: NodeList<'gc>,
    /// ESTree `expressions` property.
    pub expressions: NodeList<'gc>,
}
impl<'gc> TemplateLiteral<'gc> {
    /// Build `TemplateLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        quasis: NodeList<'gc>,
        expressions: NodeList<'gc>,
    ) -> Self {
        TemplateLiteral {
            metadata,
            quasis,
            expressions,
        }
    }
}

/// The `TaggedTemplateExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TaggedTemplateExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `tag` property.
    pub tag: &'gc Node<'gc>,
    /// ESTree `quasi` property.
    pub quasi: &'gc Node<'gc>,
}
impl<'gc> TaggedTemplateExpression<'gc> {
    /// Build `TaggedTemplateExpression` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        tag: &'gc Node<'gc>,
        quasi: &'gc Node<'gc>,
    ) -> Self {
        TaggedTemplateExpression {
            metadata,
            tag,
            quasi,
        }
    }
}

/// The `TemplateElement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TemplateElement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `tail` property.
    pub tail: Cell<bool>,
    /// ESTree `cooked` property.
    pub cooked: Cell<NodeString>,
    /// ESTree `raw` property.
    pub raw: Cell<NodeLabel>,
}
impl<'gc> TemplateElement<'gc> {
    /// Build `TemplateElement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        tail: bool,
        cooked: NodeString,
        raw: NodeLabel,
    ) -> Self {
        TemplateElement {
            metadata,
            tail: Cell::new(tail),
            cooked: Cell::new(cooked),
            raw: Cell::new(raw),
        }
    }
    /// The `cooked` string value as UTF-8, or `None` if it has no UTF-8 form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `cooked_str`: an unrepresentable
    /// identifier means something is broken, but an unrepresentable string
    /// literal is legal JS, and a codegen or refactoring tool that let U+FFFD
    /// be substituted here would silently rewrite the user's program. Reach for
    /// [`Self::cooked_str_lossy`] only when a best-effort rendering is what you
    /// want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_cooked_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.cooked.get())
    }
    /// The `cooked` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_cooked_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn cooked_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.cooked.get())
    }
    /// The `raw` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn raw_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.raw.get())
    }
}

/// The `Property` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct Property<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
    /// ESTree `kind` property.
    pub kind: Cell<NodeLabel>,
    /// ESTree `computed` property.
    pub computed: Cell<bool>,
    /// ESTree `method` property.
    pub method: Cell<bool>,
    /// ESTree `shorthand` property.
    pub shorthand: Cell<bool>,
}
impl<'gc> Property<'gc> {
    /// Build `Property` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        value: &'gc Node<'gc>,
        kind: NodeLabel,
        computed: bool,
        method: bool,
        shorthand: bool,
    ) -> Self {
        Property {
            metadata,
            key,
            value,
            kind: Cell::new(kind),
            computed: Cell::new(computed),
            method: Cell::new(method),
            shorthand: Cell::new(shorthand),
        }
    }
    /// The `kind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.kind.get())
    }
}

/// The `Decorator` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct Decorator<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
}
impl<'gc> Decorator<'gc> {
    /// Build `Decorator` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expression: &'gc Node<'gc>,
    ) -> Self {
        Decorator {
            metadata,
            expression,
        }
    }
}

/// The `ClassDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ClassDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: Option<&'gc Node<'gc>>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `superClass` property.
    pub super_class: Option<&'gc Node<'gc>>,
    /// ESTree `superTypeArguments` property.
    pub super_type_arguments: Option<&'gc Node<'gc>>,
    /// ESTree `implements` property.
    pub implements: NodeList<'gc>,
    /// ESTree `decorators` property.
    pub decorators: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` of the synthetic implicit constructor, if the
    /// class has one.
    pub implicit_ctor_function_info: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` of the synthetic function that initializes the
    /// instance elements, if the class needs one.
    pub instance_elements_init_function_info: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` of the synthetic function that runs the static
    /// field initializers, if the class has any.
    pub static_elements_init_function_info: Cell<Option<SemaId>>,
}
impl<'gc> ClassDeclaration<'gc> {
    /// Build `ClassDeclaration` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: Option<&'gc Node<'gc>>,
        type_parameters: Option<&'gc Node<'gc>>,
        super_class: Option<&'gc Node<'gc>>,
        super_type_arguments: Option<&'gc Node<'gc>>,
        implements: NodeList<'gc>,
        decorators: NodeList<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        ClassDeclaration {
            metadata,
            id,
            type_parameters,
            super_class,
            super_type_arguments,
            implements,
            decorators,
            body,
            scope: Cell::new(None),
            implicit_ctor_function_info: Cell::new(None),
            instance_elements_init_function_info: Cell::new(None),
            static_elements_init_function_info: Cell::new(None),
        }
    }
}

/// The `ClassExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ClassExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: Option<&'gc Node<'gc>>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `superClass` property.
    pub super_class: Option<&'gc Node<'gc>>,
    /// ESTree `superTypeArguments` property.
    pub super_type_arguments: Option<&'gc Node<'gc>>,
    /// ESTree `implements` property.
    pub implements: NodeList<'gc>,
    /// ESTree `decorators` property.
    pub decorators: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// Sema: the lexical scope created by this node, if any.
    pub scope: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` of the synthetic implicit constructor, if the
    /// class has one.
    pub implicit_ctor_function_info: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` of the synthetic function that initializes the
    /// instance elements, if the class needs one.
    pub instance_elements_init_function_info: Cell<Option<SemaId>>,
    /// Sema: `FunctionInfo` of the synthetic function that runs the static
    /// field initializers, if the class has any.
    pub static_elements_init_function_info: Cell<Option<SemaId>>,
}
impl<'gc> ClassExpression<'gc> {
    /// Build `ClassExpression` from its metadata and `ESTree.def` fields.
    /// Decoration fields start at their defaults.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: Option<&'gc Node<'gc>>,
        type_parameters: Option<&'gc Node<'gc>>,
        super_class: Option<&'gc Node<'gc>>,
        super_type_arguments: Option<&'gc Node<'gc>>,
        implements: NodeList<'gc>,
        decorators: NodeList<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        ClassExpression {
            metadata,
            id,
            type_parameters,
            super_class,
            super_type_arguments,
            implements,
            decorators,
            body,
            scope: Cell::new(None),
            implicit_ctor_function_info: Cell::new(None),
            instance_elements_init_function_info: Cell::new(None),
            static_elements_init_function_info: Cell::new(None),
        }
    }
}

/// The `ClassBody` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ClassBody<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `body` property.
    pub body: NodeList<'gc>,
}
impl<'gc> ClassBody<'gc> {
    /// Build `ClassBody` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        body: NodeList<'gc>,
    ) -> Self {
        ClassBody {
            metadata,
            body,
        }
    }
}

/// The `ClassProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ClassProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: Option<&'gc Node<'gc>>,
    /// ESTree `computed` property.
    pub computed: Cell<bool>,
    /// ESTree `static` property.
    pub r#static: Cell<bool>,
    /// ESTree `decorators` property.
    pub decorators: NodeList<'gc>,
    /// ESTree `declare` property.
    pub declare: Cell<bool>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
    /// ESTree `variance` property.
    pub variance: Option<&'gc Node<'gc>>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: Option<&'gc Node<'gc>>,
    /// ESTree `tsModifiers` property.
    pub ts_modifiers: Option<&'gc Node<'gc>>,
}
impl<'gc> ClassProperty<'gc> {
    /// Build `ClassProperty` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        value: Option<&'gc Node<'gc>>,
        computed: bool,
        r#static: bool,
        decorators: NodeList<'gc>,
        declare: bool,
        optional: bool,
        variance: Option<&'gc Node<'gc>>,
        type_annotation: Option<&'gc Node<'gc>>,
        ts_modifiers: Option<&'gc Node<'gc>>,
    ) -> Self {
        ClassProperty {
            metadata,
            key,
            value,
            computed: Cell::new(computed),
            r#static: Cell::new(r#static),
            decorators,
            declare: Cell::new(declare),
            optional: Cell::new(optional),
            variance,
            type_annotation,
            ts_modifiers,
        }
    }
}

/// The `ClassPrivateProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ClassPrivateProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: Option<&'gc Node<'gc>>,
    /// ESTree `static` property.
    pub r#static: Cell<bool>,
    /// ESTree `decorators` property.
    pub decorators: NodeList<'gc>,
    /// ESTree `declare` property.
    pub declare: Cell<bool>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
    /// ESTree `variance` property.
    pub variance: Option<&'gc Node<'gc>>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: Option<&'gc Node<'gc>>,
    /// ESTree `tsModifiers` property.
    pub ts_modifiers: Option<&'gc Node<'gc>>,
}
impl<'gc> ClassPrivateProperty<'gc> {
    /// Build `ClassPrivateProperty` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        value: Option<&'gc Node<'gc>>,
        r#static: bool,
        decorators: NodeList<'gc>,
        declare: bool,
        optional: bool,
        variance: Option<&'gc Node<'gc>>,
        type_annotation: Option<&'gc Node<'gc>>,
        ts_modifiers: Option<&'gc Node<'gc>>,
    ) -> Self {
        ClassPrivateProperty {
            metadata,
            key,
            value,
            r#static: Cell::new(r#static),
            decorators,
            declare: Cell::new(declare),
            optional: Cell::new(optional),
            variance,
            type_annotation,
            ts_modifiers,
        }
    }
}

/// The `MethodDefinition` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MethodDefinition<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
    /// ESTree `kind` property.
    pub kind: Cell<NodeLabel>,
    /// ESTree `computed` property.
    pub computed: Cell<bool>,
    /// ESTree `static` property.
    pub r#static: Cell<bool>,
    /// ESTree `decorators` property.
    pub decorators: NodeList<'gc>,
}
impl<'gc> MethodDefinition<'gc> {
    /// Build `MethodDefinition` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        value: &'gc Node<'gc>,
        kind: NodeLabel,
        computed: bool,
        r#static: bool,
        decorators: NodeList<'gc>,
    ) -> Self {
        MethodDefinition {
            metadata,
            key,
            value,
            kind: Cell::new(kind),
            computed: Cell::new(computed),
            r#static: Cell::new(r#static),
            decorators,
        }
    }
    /// The `kind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.kind.get())
    }
}

/// The `ImportDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ImportDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `specifiers` property.
    pub specifiers: NodeList<'gc>,
    /// ESTree `source` property.
    pub source: &'gc Node<'gc>,
    /// ESTree `attributes` property.
    pub attributes: NodeList<'gc>,
    /// ESTree `importKind` property.
    pub import_kind: Cell<NodeLabel>,
}
impl<'gc> ImportDeclaration<'gc> {
    /// Build `ImportDeclaration` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        specifiers: NodeList<'gc>,
        source: &'gc Node<'gc>,
        attributes: NodeList<'gc>,
        import_kind: NodeLabel,
    ) -> Self {
        ImportDeclaration {
            metadata,
            specifiers,
            source,
            attributes,
            import_kind: Cell::new(import_kind),
        }
    }
    /// The `importKind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn import_kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.import_kind.get())
    }
}

/// The `ImportSpecifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ImportSpecifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `imported` property.
    pub imported: &'gc Node<'gc>,
    /// ESTree `local` property.
    pub local: &'gc Node<'gc>,
    /// ESTree `importKind` property.
    pub import_kind: Cell<NodeLabel>,
}
impl<'gc> ImportSpecifier<'gc> {
    /// Build `ImportSpecifier` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        imported: &'gc Node<'gc>,
        local: &'gc Node<'gc>,
        import_kind: NodeLabel,
    ) -> Self {
        ImportSpecifier {
            metadata,
            imported,
            local,
            import_kind: Cell::new(import_kind),
        }
    }
    /// The `importKind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn import_kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.import_kind.get())
    }
}

/// The `ImportDefaultSpecifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ImportDefaultSpecifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `local` property.
    pub local: &'gc Node<'gc>,
}
impl<'gc> ImportDefaultSpecifier<'gc> {
    /// Build `ImportDefaultSpecifier` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        local: &'gc Node<'gc>,
    ) -> Self {
        ImportDefaultSpecifier {
            metadata,
            local,
        }
    }
}

/// The `ImportNamespaceSpecifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ImportNamespaceSpecifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `local` property.
    pub local: &'gc Node<'gc>,
}
impl<'gc> ImportNamespaceSpecifier<'gc> {
    /// Build `ImportNamespaceSpecifier` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        local: &'gc Node<'gc>,
    ) -> Self {
        ImportNamespaceSpecifier {
            metadata,
            local,
        }
    }
}

/// The `ImportAttribute` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ImportAttribute<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
}
impl<'gc> ImportAttribute<'gc> {
    /// Build `ImportAttribute` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        value: &'gc Node<'gc>,
    ) -> Self {
        ImportAttribute {
            metadata,
            key,
            value,
        }
    }
}

/// The `ExportNamedDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ExportNamedDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `declaration` property.
    pub declaration: Option<&'gc Node<'gc>>,
    /// ESTree `specifiers` property.
    pub specifiers: NodeList<'gc>,
    /// ESTree `source` property.
    pub source: Option<&'gc Node<'gc>>,
    /// ESTree `exportKind` property.
    pub export_kind: Cell<NodeLabel>,
}
impl<'gc> ExportNamedDeclaration<'gc> {
    /// Build `ExportNamedDeclaration` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        declaration: Option<&'gc Node<'gc>>,
        specifiers: NodeList<'gc>,
        source: Option<&'gc Node<'gc>>,
        export_kind: NodeLabel,
    ) -> Self {
        ExportNamedDeclaration {
            metadata,
            declaration,
            specifiers,
            source,
            export_kind: Cell::new(export_kind),
        }
    }
    /// The `exportKind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn export_kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.export_kind.get())
    }
}

/// The `ExportSpecifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ExportSpecifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `exported` property.
    pub exported: &'gc Node<'gc>,
    /// ESTree `local` property.
    pub local: &'gc Node<'gc>,
}
impl<'gc> ExportSpecifier<'gc> {
    /// Build `ExportSpecifier` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        exported: &'gc Node<'gc>,
        local: &'gc Node<'gc>,
    ) -> Self {
        ExportSpecifier {
            metadata,
            exported,
            local,
        }
    }
}

/// The `ExportNamespaceSpecifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ExportNamespaceSpecifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `exported` property.
    pub exported: &'gc Node<'gc>,
}
impl<'gc> ExportNamespaceSpecifier<'gc> {
    /// Build `ExportNamespaceSpecifier` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        exported: &'gc Node<'gc>,
    ) -> Self {
        ExportNamespaceSpecifier {
            metadata,
            exported,
        }
    }
}

/// The `ExportDefaultDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ExportDefaultDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `declaration` property.
    pub declaration: &'gc Node<'gc>,
}
impl<'gc> ExportDefaultDeclaration<'gc> {
    /// Build `ExportDefaultDeclaration` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        declaration: &'gc Node<'gc>,
    ) -> Self {
        ExportDefaultDeclaration {
            metadata,
            declaration,
        }
    }
}

/// The `ExportAllDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ExportAllDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `source` property.
    pub source: &'gc Node<'gc>,
    /// ESTree `exportKind` property.
    pub export_kind: Cell<NodeLabel>,
}
impl<'gc> ExportAllDeclaration<'gc> {
    /// Build `ExportAllDeclaration` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        source: &'gc Node<'gc>,
        export_kind: NodeLabel,
    ) -> Self {
        ExportAllDeclaration {
            metadata,
            source,
            export_kind: Cell::new(export_kind),
        }
    }
    /// The `exportKind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn export_kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.export_kind.get())
    }
}

/// The `ObjectPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ObjectPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `properties` property.
    pub properties: NodeList<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: Option<&'gc Node<'gc>>,
}
impl<'gc> ObjectPattern<'gc> {
    /// Build `ObjectPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        properties: NodeList<'gc>,
        type_annotation: Option<&'gc Node<'gc>>,
    ) -> Self {
        ObjectPattern {
            metadata,
            properties,
            type_annotation,
        }
    }
}

/// The `ArrayPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ArrayPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `elements` property.
    pub elements: NodeList<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: Option<&'gc Node<'gc>>,
}
impl<'gc> ArrayPattern<'gc> {
    /// Build `ArrayPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        elements: NodeList<'gc>,
        type_annotation: Option<&'gc Node<'gc>>,
    ) -> Self {
        ArrayPattern {
            metadata,
            elements,
            type_annotation,
        }
    }
}

/// The `RestElement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct RestElement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
}
impl<'gc> RestElement<'gc> {
    /// Build `RestElement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
    ) -> Self {
        RestElement {
            metadata,
            argument,
        }
    }
}

/// The `AssignmentPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct AssignmentPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `left` property.
    pub left: &'gc Node<'gc>,
    /// ESTree `right` property.
    pub right: &'gc Node<'gc>,
}
impl<'gc> AssignmentPattern<'gc> {
    /// Build `AssignmentPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        left: &'gc Node<'gc>,
        right: &'gc Node<'gc>,
    ) -> Self {
        AssignmentPattern {
            metadata,
            left,
            right,
        }
    }
}

/// The `MatchStatementCase` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchStatementCase<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `pattern` property.
    pub pattern: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `guard` property.
    pub guard: Option<&'gc Node<'gc>>,
}
impl<'gc> MatchStatementCase<'gc> {
    /// Build `MatchStatementCase` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        pattern: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
        guard: Option<&'gc Node<'gc>>,
    ) -> Self {
        MatchStatementCase {
            metadata,
            pattern,
            body,
            guard,
        }
    }
}

/// The `MatchExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
    /// ESTree `cases` property.
    pub cases: NodeList<'gc>,
}
impl<'gc> MatchExpression<'gc> {
    /// Build `MatchExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
        cases: NodeList<'gc>,
    ) -> Self {
        MatchExpression {
            metadata,
            argument,
            cases,
        }
    }
}

/// The `MatchExpressionCase` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchExpressionCase<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `pattern` property.
    pub pattern: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `guard` property.
    pub guard: Option<&'gc Node<'gc>>,
}
impl<'gc> MatchExpressionCase<'gc> {
    /// Build `MatchExpressionCase` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        pattern: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
        guard: Option<&'gc Node<'gc>>,
    ) -> Self {
        MatchExpressionCase {
            metadata,
            pattern,
            body,
            guard,
        }
    }
}

/// The `MatchWildcardPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchWildcardPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> MatchWildcardPattern<'gc> {
    /// Build `MatchWildcardPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        MatchWildcardPattern {
            metadata,
        }
    }
}

/// The `MatchLiteralPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchLiteralPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `literal` property.
    pub literal: &'gc Node<'gc>,
}
impl<'gc> MatchLiteralPattern<'gc> {
    /// Build `MatchLiteralPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        literal: &'gc Node<'gc>,
    ) -> Self {
        MatchLiteralPattern {
            metadata,
            literal,
        }
    }
}

/// The `MatchUnaryPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchUnaryPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
    /// ESTree `operator` property.
    pub operator: Cell<NodeLabel>,
}
impl<'gc> MatchUnaryPattern<'gc> {
    /// Build `MatchUnaryPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
        operator: NodeLabel,
    ) -> Self {
        MatchUnaryPattern {
            metadata,
            argument,
            operator: Cell::new(operator),
        }
    }
    /// The `operator` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn operator_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.operator.get())
    }
}

/// The `MatchIdentifierPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchIdentifierPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
}
impl<'gc> MatchIdentifierPattern<'gc> {
    /// Build `MatchIdentifierPattern` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
    ) -> Self {
        MatchIdentifierPattern {
            metadata,
            id,
        }
    }
}

/// The `MatchBindingPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchBindingPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `kind` property.
    pub kind: Cell<NodeLabel>,
}
impl<'gc> MatchBindingPattern<'gc> {
    /// Build `MatchBindingPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        kind: NodeLabel,
    ) -> Self {
        MatchBindingPattern {
            metadata,
            id,
            kind: Cell::new(kind),
        }
    }
    /// The `kind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.kind.get())
    }
}

/// The `MatchObjectPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchObjectPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `properties` property.
    pub properties: NodeList<'gc>,
    /// ESTree `rest` property.
    pub rest: Option<&'gc Node<'gc>>,
}
impl<'gc> MatchObjectPattern<'gc> {
    /// Build `MatchObjectPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        properties: NodeList<'gc>,
        rest: Option<&'gc Node<'gc>>,
    ) -> Self {
        MatchObjectPattern {
            metadata,
            properties,
            rest,
        }
    }
}

/// The `MatchArrayPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchArrayPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `elements` property.
    pub elements: NodeList<'gc>,
    /// ESTree `rest` property.
    pub rest: Option<&'gc Node<'gc>>,
}
impl<'gc> MatchArrayPattern<'gc> {
    /// Build `MatchArrayPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        elements: NodeList<'gc>,
        rest: Option<&'gc Node<'gc>>,
    ) -> Self {
        MatchArrayPattern {
            metadata,
            elements,
            rest,
        }
    }
}

/// The `MatchOrPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchOrPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `patterns` property.
    pub patterns: NodeList<'gc>,
}
impl<'gc> MatchOrPattern<'gc> {
    /// Build `MatchOrPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        patterns: NodeList<'gc>,
    ) -> Self {
        MatchOrPattern {
            metadata,
            patterns,
        }
    }
}

/// The `MatchAsPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchAsPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `pattern` property.
    pub pattern: &'gc Node<'gc>,
    /// ESTree `target` property.
    pub target: &'gc Node<'gc>,
}
impl<'gc> MatchAsPattern<'gc> {
    /// Build `MatchAsPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        pattern: &'gc Node<'gc>,
        target: &'gc Node<'gc>,
    ) -> Self {
        MatchAsPattern {
            metadata,
            pattern,
            target,
        }
    }
}

/// The `MatchMemberPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchMemberPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `base` property.
    pub base: &'gc Node<'gc>,
    /// ESTree `property` property.
    pub property: &'gc Node<'gc>,
}
impl<'gc> MatchMemberPattern<'gc> {
    /// Build `MatchMemberPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        base: &'gc Node<'gc>,
        property: &'gc Node<'gc>,
    ) -> Self {
        MatchMemberPattern {
            metadata,
            base,
            property,
        }
    }
}

/// The `MatchInstancePattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchInstancePattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `targetConstructor` property.
    pub target_constructor: &'gc Node<'gc>,
    /// ESTree `properties` property.
    pub properties: &'gc Node<'gc>,
}
impl<'gc> MatchInstancePattern<'gc> {
    /// Build `MatchInstancePattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        target_constructor: &'gc Node<'gc>,
        properties: &'gc Node<'gc>,
    ) -> Self {
        MatchInstancePattern {
            metadata,
            target_constructor,
            properties,
        }
    }
}

/// The `MatchObjectPatternProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchObjectPatternProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `pattern` property.
    pub pattern: &'gc Node<'gc>,
    /// ESTree `shorthand` property.
    pub shorthand: Cell<bool>,
}
impl<'gc> MatchObjectPatternProperty<'gc> {
    /// Build `MatchObjectPatternProperty` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        pattern: &'gc Node<'gc>,
        shorthand: bool,
    ) -> Self {
        MatchObjectPatternProperty {
            metadata,
            key,
            pattern,
            shorthand: Cell::new(shorthand),
        }
    }
}

/// The `MatchInstanceObjectPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchInstanceObjectPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `properties` property.
    pub properties: NodeList<'gc>,
    /// ESTree `rest` property.
    pub rest: Option<&'gc Node<'gc>>,
}
impl<'gc> MatchInstanceObjectPattern<'gc> {
    /// Build `MatchInstanceObjectPattern` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        properties: NodeList<'gc>,
        rest: Option<&'gc Node<'gc>>,
    ) -> Self {
        MatchInstanceObjectPattern {
            metadata,
            properties,
            rest,
        }
    }
}

/// The `MatchRestPattern` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MatchRestPattern<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: Option<&'gc Node<'gc>>,
}
impl<'gc> MatchRestPattern<'gc> {
    /// Build `MatchRestPattern` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: Option<&'gc Node<'gc>>,
    ) -> Self {
        MatchRestPattern {
            metadata,
            argument,
        }
    }
}

/// The `JSXIdentifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXIdentifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: Cell<NodeLabel>,
}
impl<'gc> JSXIdentifier<'gc> {
    /// Build `JSXIdentifier` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: NodeLabel,
    ) -> Self {
        JSXIdentifier {
            metadata,
            name: Cell::new(name),
        }
    }
    /// The `name` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn name_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.name.get())
    }
}

/// The `JSXMemberExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXMemberExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `object` property.
    pub object: &'gc Node<'gc>,
    /// ESTree `property` property.
    pub property: &'gc Node<'gc>,
}
impl<'gc> JSXMemberExpression<'gc> {
    /// Build `JSXMemberExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        object: &'gc Node<'gc>,
        property: &'gc Node<'gc>,
    ) -> Self {
        JSXMemberExpression {
            metadata,
            object,
            property,
        }
    }
}

/// The `JSXNamespacedName` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXNamespacedName<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `namespace` property.
    pub namespace: &'gc Node<'gc>,
    /// ESTree `name` property.
    pub name: &'gc Node<'gc>,
}
impl<'gc> JSXNamespacedName<'gc> {
    /// Build `JSXNamespacedName` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        namespace: &'gc Node<'gc>,
        name: &'gc Node<'gc>,
    ) -> Self {
        JSXNamespacedName {
            metadata,
            namespace,
            name,
        }
    }
}

/// The `JSXEmptyExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXEmptyExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> JSXEmptyExpression<'gc> {
    /// Build `JSXEmptyExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        JSXEmptyExpression {
            metadata,
        }
    }
}

/// The `JSXExpressionContainer` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXExpressionContainer<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
}
impl<'gc> JSXExpressionContainer<'gc> {
    /// Build `JSXExpressionContainer` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expression: &'gc Node<'gc>,
    ) -> Self {
        JSXExpressionContainer {
            metadata,
            expression,
        }
    }
}

/// The `JSXSpreadChild` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXSpreadChild<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
}
impl<'gc> JSXSpreadChild<'gc> {
    /// Build `JSXSpreadChild` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expression: &'gc Node<'gc>,
    ) -> Self {
        JSXSpreadChild {
            metadata,
            expression,
        }
    }
}

/// The `JSXOpeningElement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXOpeningElement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: &'gc Node<'gc>,
    /// ESTree `attributes` property.
    pub attributes: NodeList<'gc>,
    /// ESTree `selfClosing` property.
    pub self_closing: Cell<bool>,
    /// ESTree `typeArguments` property.
    pub type_arguments: Option<&'gc Node<'gc>>,
}
impl<'gc> JSXOpeningElement<'gc> {
    /// Build `JSXOpeningElement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: &'gc Node<'gc>,
        attributes: NodeList<'gc>,
        self_closing: bool,
        type_arguments: Option<&'gc Node<'gc>>,
    ) -> Self {
        JSXOpeningElement {
            metadata,
            name,
            attributes,
            self_closing: Cell::new(self_closing),
            type_arguments,
        }
    }
}

/// The `JSXClosingElement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXClosingElement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: &'gc Node<'gc>,
}
impl<'gc> JSXClosingElement<'gc> {
    /// Build `JSXClosingElement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: &'gc Node<'gc>,
    ) -> Self {
        JSXClosingElement {
            metadata,
            name,
        }
    }
}

/// The `JSXAttribute` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXAttribute<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: Option<&'gc Node<'gc>>,
}
impl<'gc> JSXAttribute<'gc> {
    /// Build `JSXAttribute` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: &'gc Node<'gc>,
        value: Option<&'gc Node<'gc>>,
    ) -> Self {
        JSXAttribute {
            metadata,
            name,
            value,
        }
    }
}

/// The `JSXSpreadAttribute` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXSpreadAttribute<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
}
impl<'gc> JSXSpreadAttribute<'gc> {
    /// Build `JSXSpreadAttribute` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
    ) -> Self {
        JSXSpreadAttribute {
            metadata,
            argument,
        }
    }
}

/// The `JSXStringLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXStringLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: Cell<NodeString>,
    /// ESTree `raw` property.
    pub raw: Cell<NodeLabel>,
}
impl<'gc> JSXStringLiteral<'gc> {
    /// Build `JSXStringLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: NodeString,
        raw: NodeLabel,
    ) -> Self {
        JSXStringLiteral {
            metadata,
            value: Cell::new(value),
            raw: Cell::new(raw),
        }
    }
    /// The `value` string value as UTF-8, or `None` if it has no UTF-8 form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `value_str`: an unrepresentable
    /// identifier means something is broken, but an unrepresentable string
    /// literal is legal JS, and a codegen or refactoring tool that let U+FFFD
    /// be substituted here would silently rewrite the user's program. Reach for
    /// [`Self::value_str_lossy`] only when a best-effort rendering is what you
    /// want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_value_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.value.get())
    }
    /// The `value` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_value_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn value_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.value.get())
    }
    /// The `raw` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn raw_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.raw.get())
    }
}

/// The `JSXText` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXText<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: Cell<NodeString>,
    /// ESTree `raw` property.
    pub raw: Cell<NodeLabel>,
}
impl<'gc> JSXText<'gc> {
    /// Build `JSXText` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: NodeString,
        raw: NodeLabel,
    ) -> Self {
        JSXText {
            metadata,
            value: Cell::new(value),
            raw: Cell::new(raw),
        }
    }
    /// The `value` string value as UTF-8, or `None` if it has no UTF-8 form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `value_str`: an unrepresentable
    /// identifier means something is broken, but an unrepresentable string
    /// literal is legal JS, and a codegen or refactoring tool that let U+FFFD
    /// be substituted here would silently rewrite the user's program. Reach for
    /// [`Self::value_str_lossy`] only when a best-effort rendering is what you
    /// want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_value_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.value.get())
    }
    /// The `value` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_value_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn value_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.value.get())
    }
    /// The `raw` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn raw_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.raw.get())
    }
}

/// The `JSXElement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXElement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `openingElement` property.
    pub opening_element: &'gc Node<'gc>,
    /// ESTree `children` property.
    pub children: NodeList<'gc>,
    /// ESTree `closingElement` property.
    pub closing_element: Option<&'gc Node<'gc>>,
}
impl<'gc> JSXElement<'gc> {
    /// Build `JSXElement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        opening_element: &'gc Node<'gc>,
        children: NodeList<'gc>,
        closing_element: Option<&'gc Node<'gc>>,
    ) -> Self {
        JSXElement {
            metadata,
            opening_element,
            children,
            closing_element,
        }
    }
}

/// The `JSXFragment` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXFragment<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `openingFragment` property.
    pub opening_fragment: &'gc Node<'gc>,
    /// ESTree `children` property.
    pub children: NodeList<'gc>,
    /// ESTree `closingFragment` property.
    pub closing_fragment: &'gc Node<'gc>,
}
impl<'gc> JSXFragment<'gc> {
    /// Build `JSXFragment` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        opening_fragment: &'gc Node<'gc>,
        children: NodeList<'gc>,
        closing_fragment: &'gc Node<'gc>,
    ) -> Self {
        JSXFragment {
            metadata,
            opening_fragment,
            children,
            closing_fragment,
        }
    }
}

/// The `JSXOpeningFragment` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXOpeningFragment<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> JSXOpeningFragment<'gc> {
    /// Build `JSXOpeningFragment` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        JSXOpeningFragment {
            metadata,
        }
    }
}

/// The `JSXClosingFragment` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct JSXClosingFragment<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> JSXClosingFragment<'gc> {
    /// Build `JSXClosingFragment` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        JSXClosingFragment {
            metadata,
        }
    }
}

/// The `ExistsTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ExistsTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> ExistsTypeAnnotation<'gc> {
    /// Build `ExistsTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        ExistsTypeAnnotation {
            metadata,
        }
    }
}

/// The `EmptyTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EmptyTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> EmptyTypeAnnotation<'gc> {
    /// Build `EmptyTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        EmptyTypeAnnotation {
            metadata,
        }
    }
}

/// The `StringTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct StringTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> StringTypeAnnotation<'gc> {
    /// Build `StringTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        StringTypeAnnotation {
            metadata,
        }
    }
}

/// The `NumberTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct NumberTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> NumberTypeAnnotation<'gc> {
    /// Build `NumberTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        NumberTypeAnnotation {
            metadata,
        }
    }
}

/// The `StringLiteralTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct StringLiteralTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: Cell<NodeString>,
    /// ESTree `raw` property.
    pub raw: Cell<NodeString>,
}
impl<'gc> StringLiteralTypeAnnotation<'gc> {
    /// Build `StringLiteralTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: NodeString,
        raw: NodeString,
    ) -> Self {
        StringLiteralTypeAnnotation {
            metadata,
            value: Cell::new(value),
            raw: Cell::new(raw),
        }
    }
    /// The `value` string value as UTF-8, or `None` if it has no UTF-8 form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `value_str`: an unrepresentable
    /// identifier means something is broken, but an unrepresentable string
    /// literal is legal JS, and a codegen or refactoring tool that let U+FFFD
    /// be substituted here would silently rewrite the user's program. Reach for
    /// [`Self::value_str_lossy`] only when a best-effort rendering is what you
    /// want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_value_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.value.get())
    }
    /// The `value` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_value_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn value_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.value.get())
    }
    /// The `raw` string value as UTF-8, or `None` if it has no UTF-8 form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `raw_str`: an unrepresentable identifier
    /// means something is broken, but an unrepresentable string literal is
    /// legal JS, and a codegen or refactoring tool that let U+FFFD be
    /// substituted here would silently rewrite the user's program. Reach for
    /// [`Self::raw_str_lossy`] only when a best-effort rendering is what you
    /// want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_raw_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.raw.get())
    }
    /// The `raw` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_raw_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn raw_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.raw.get())
    }
}

/// The `NumberLiteralTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct NumberLiteralTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: Cell<f64>,
    /// ESTree `raw` property.
    pub raw: Cell<NodeLabel>,
}
impl<'gc> NumberLiteralTypeAnnotation<'gc> {
    /// Build `NumberLiteralTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: f64,
        raw: NodeLabel,
    ) -> Self {
        NumberLiteralTypeAnnotation {
            metadata,
            value: Cell::new(value),
            raw: Cell::new(raw),
        }
    }
    /// The `raw` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn raw_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.raw.get())
    }
}

/// The `BigIntLiteralTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct BigIntLiteralTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `raw` property.
    pub raw: Cell<NodeLabel>,
}
impl<'gc> BigIntLiteralTypeAnnotation<'gc> {
    /// Build `BigIntLiteralTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        raw: NodeLabel,
    ) -> Self {
        BigIntLiteralTypeAnnotation {
            metadata,
            raw: Cell::new(raw),
        }
    }
    /// The `raw` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn raw_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.raw.get())
    }
}

/// The `BooleanTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct BooleanTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> BooleanTypeAnnotation<'gc> {
    /// Build `BooleanTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        BooleanTypeAnnotation {
            metadata,
        }
    }
}

/// The `BooleanLiteralTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct BooleanLiteralTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: Cell<bool>,
    /// ESTree `raw` property.
    pub raw: Cell<NodeLabel>,
}
impl<'gc> BooleanLiteralTypeAnnotation<'gc> {
    /// Build `BooleanLiteralTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: bool,
        raw: NodeLabel,
    ) -> Self {
        BooleanLiteralTypeAnnotation {
            metadata,
            value: Cell::new(value),
            raw: Cell::new(raw),
        }
    }
    /// The `raw` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn raw_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.raw.get())
    }
}

/// The `NullLiteralTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct NullLiteralTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> NullLiteralTypeAnnotation<'gc> {
    /// Build `NullLiteralTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        NullLiteralTypeAnnotation {
            metadata,
        }
    }
}

/// The `SymbolTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct SymbolTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> SymbolTypeAnnotation<'gc> {
    /// Build `SymbolTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        SymbolTypeAnnotation {
            metadata,
        }
    }
}

/// The `AnyTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct AnyTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> AnyTypeAnnotation<'gc> {
    /// Build `AnyTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        AnyTypeAnnotation {
            metadata,
        }
    }
}

/// The `MixedTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct MixedTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> MixedTypeAnnotation<'gc> {
    /// Build `MixedTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        MixedTypeAnnotation {
            metadata,
        }
    }
}

/// The `BigIntTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct BigIntTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> BigIntTypeAnnotation<'gc> {
    /// Build `BigIntTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        BigIntTypeAnnotation {
            metadata,
        }
    }
}

/// The `VoidTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct VoidTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> VoidTypeAnnotation<'gc> {
    /// Build `VoidTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        VoidTypeAnnotation {
            metadata,
        }
    }
}

/// The `NeverTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct NeverTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> NeverTypeAnnotation<'gc> {
    /// Build `NeverTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        NeverTypeAnnotation {
            metadata,
        }
    }
}

/// The `UnknownTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct UnknownTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> UnknownTypeAnnotation<'gc> {
    /// Build `UnknownTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        UnknownTypeAnnotation {
            metadata,
        }
    }
}

/// The `UndefinedTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct UndefinedTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> UndefinedTypeAnnotation<'gc> {
    /// Build `UndefinedTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        UndefinedTypeAnnotation {
            metadata,
        }
    }
}

/// The `FunctionTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct FunctionTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `this` property.
    pub this: Option<&'gc Node<'gc>>,
    /// ESTree `returnType` property.
    pub return_type: &'gc Node<'gc>,
    /// ESTree `rest` property.
    pub rest: Option<&'gc Node<'gc>>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> FunctionTypeAnnotation<'gc> {
    /// Build `FunctionTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
        this: Option<&'gc Node<'gc>>,
        return_type: &'gc Node<'gc>,
        rest: Option<&'gc Node<'gc>>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        FunctionTypeAnnotation {
            metadata,
            params,
            this,
            return_type,
            rest,
            type_parameters,
        }
    }
}

/// The `HookTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct HookTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `returnType` property.
    pub return_type: &'gc Node<'gc>,
    /// ESTree `rest` property.
    pub rest: Option<&'gc Node<'gc>>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> HookTypeAnnotation<'gc> {
    /// Build `HookTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
        return_type: &'gc Node<'gc>,
        rest: Option<&'gc Node<'gc>>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        HookTypeAnnotation {
            metadata,
            params,
            return_type,
            rest,
            type_parameters,
        }
    }
}

/// The `FunctionTypeParam` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct FunctionTypeParam<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: Option<&'gc Node<'gc>>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
}
impl<'gc> FunctionTypeParam<'gc> {
    /// Build `FunctionTypeParam` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: Option<&'gc Node<'gc>>,
        type_annotation: &'gc Node<'gc>,
        optional: bool,
    ) -> Self {
        FunctionTypeParam {
            metadata,
            name,
            type_annotation,
            optional: Cell::new(optional),
        }
    }
}

/// The `ComponentTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ComponentTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `rest` property.
    pub rest: Option<&'gc Node<'gc>>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `rendersType` property.
    pub renders_type: Option<&'gc Node<'gc>>,
}
impl<'gc> ComponentTypeAnnotation<'gc> {
    /// Build `ComponentTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
        rest: Option<&'gc Node<'gc>>,
        type_parameters: Option<&'gc Node<'gc>>,
        renders_type: Option<&'gc Node<'gc>>,
    ) -> Self {
        ComponentTypeAnnotation {
            metadata,
            params,
            rest,
            type_parameters,
            renders_type,
        }
    }
}

/// The `ComponentTypeParameter` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ComponentTypeParameter<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: Option<&'gc Node<'gc>>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
}
impl<'gc> ComponentTypeParameter<'gc> {
    /// Build `ComponentTypeParameter` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: Option<&'gc Node<'gc>>,
        type_annotation: &'gc Node<'gc>,
        optional: bool,
    ) -> Self {
        ComponentTypeParameter {
            metadata,
            name,
            type_annotation,
            optional: Cell::new(optional),
        }
    }
}

/// The `NullableTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct NullableTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> NullableTypeAnnotation<'gc> {
    /// Build `NullableTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        NullableTypeAnnotation {
            metadata,
            type_annotation,
        }
    }
}

/// The `QualifiedTypeIdentifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct QualifiedTypeIdentifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `qualification` property.
    pub qualification: &'gc Node<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
}
impl<'gc> QualifiedTypeIdentifier<'gc> {
    /// Build `QualifiedTypeIdentifier` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        qualification: &'gc Node<'gc>,
        id: &'gc Node<'gc>,
    ) -> Self {
        QualifiedTypeIdentifier {
            metadata,
            qualification,
            id,
        }
    }
}

/// The `TypeofTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TypeofTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
    /// ESTree `typeArguments` property.
    pub type_arguments: Option<&'gc Node<'gc>>,
}
impl<'gc> TypeofTypeAnnotation<'gc> {
    /// Build `TypeofTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
        type_arguments: Option<&'gc Node<'gc>>,
    ) -> Self {
        TypeofTypeAnnotation {
            metadata,
            argument,
            type_arguments,
        }
    }
}

/// The `KeyofTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct KeyofTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
}
impl<'gc> KeyofTypeAnnotation<'gc> {
    /// Build `KeyofTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
    ) -> Self {
        KeyofTypeAnnotation {
            metadata,
            argument,
        }
    }
}

/// The `TypeOperator` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TypeOperator<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `operator` property.
    pub operator: Cell<NodeLabel>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> TypeOperator<'gc> {
    /// Build `TypeOperator` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        operator: NodeLabel,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        TypeOperator {
            metadata,
            operator: Cell::new(operator),
            type_annotation,
        }
    }
    /// The `operator` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn operator_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.operator.get())
    }
}

/// The `QualifiedTypeofIdentifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct QualifiedTypeofIdentifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `qualification` property.
    pub qualification: &'gc Node<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
}
impl<'gc> QualifiedTypeofIdentifier<'gc> {
    /// Build `QualifiedTypeofIdentifier` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        qualification: &'gc Node<'gc>,
        id: &'gc Node<'gc>,
    ) -> Self {
        QualifiedTypeofIdentifier {
            metadata,
            qualification,
            id,
        }
    }
}

/// The `TupleTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TupleTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `elementTypes` property.
    pub element_types: NodeList<'gc>,
    /// ESTree `inexact` property.
    pub inexact: Cell<bool>,
}
impl<'gc> TupleTypeAnnotation<'gc> {
    /// Build `TupleTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        element_types: NodeList<'gc>,
        inexact: bool,
    ) -> Self {
        TupleTypeAnnotation {
            metadata,
            element_types,
            inexact: Cell::new(inexact),
        }
    }
}

/// The `TupleTypeSpreadElement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TupleTypeSpreadElement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `label` property.
    pub label: Option<&'gc Node<'gc>>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> TupleTypeSpreadElement<'gc> {
    /// Build `TupleTypeSpreadElement` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        label: Option<&'gc Node<'gc>>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        TupleTypeSpreadElement {
            metadata,
            label,
            type_annotation,
        }
    }
}

/// The `TupleTypeLabeledElement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TupleTypeLabeledElement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `label` property.
    pub label: &'gc Node<'gc>,
    /// ESTree `elementType` property.
    pub element_type: &'gc Node<'gc>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
    /// ESTree `variance` property.
    pub variance: Option<&'gc Node<'gc>>,
}
impl<'gc> TupleTypeLabeledElement<'gc> {
    /// Build `TupleTypeLabeledElement` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        label: &'gc Node<'gc>,
        element_type: &'gc Node<'gc>,
        optional: bool,
        variance: Option<&'gc Node<'gc>>,
    ) -> Self {
        TupleTypeLabeledElement {
            metadata,
            label,
            element_type,
            optional: Cell::new(optional),
            variance,
        }
    }
}

/// The `ArrayTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ArrayTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `elementType` property.
    pub element_type: &'gc Node<'gc>,
}
impl<'gc> ArrayTypeAnnotation<'gc> {
    /// Build `ArrayTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        element_type: &'gc Node<'gc>,
    ) -> Self {
        ArrayTypeAnnotation {
            metadata,
            element_type,
        }
    }
}

/// The `InferTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct InferTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `typeParameter` property.
    pub type_parameter: &'gc Node<'gc>,
}
impl<'gc> InferTypeAnnotation<'gc> {
    /// Build `InferTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        type_parameter: &'gc Node<'gc>,
    ) -> Self {
        InferTypeAnnotation {
            metadata,
            type_parameter,
        }
    }
}

/// The `UnionTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct UnionTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `types` property.
    pub types: NodeList<'gc>,
}
impl<'gc> UnionTypeAnnotation<'gc> {
    /// Build `UnionTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        types: NodeList<'gc>,
    ) -> Self {
        UnionTypeAnnotation {
            metadata,
            types,
        }
    }
}

/// The `IntersectionTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct IntersectionTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `types` property.
    pub types: NodeList<'gc>,
}
impl<'gc> IntersectionTypeAnnotation<'gc> {
    /// Build `IntersectionTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        types: NodeList<'gc>,
    ) -> Self {
        IntersectionTypeAnnotation {
            metadata,
            types,
        }
    }
}

/// The `GenericTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct GenericTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> GenericTypeAnnotation<'gc> {
    /// Build `GenericTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        GenericTypeAnnotation {
            metadata,
            id,
            type_parameters,
        }
    }
}

/// The `IndexedAccessType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct IndexedAccessType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `objectType` property.
    pub object_type: &'gc Node<'gc>,
    /// ESTree `indexType` property.
    pub index_type: &'gc Node<'gc>,
}
impl<'gc> IndexedAccessType<'gc> {
    /// Build `IndexedAccessType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        object_type: &'gc Node<'gc>,
        index_type: &'gc Node<'gc>,
    ) -> Self {
        IndexedAccessType {
            metadata,
            object_type,
            index_type,
        }
    }
}

/// The `OptionalIndexedAccessType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct OptionalIndexedAccessType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `objectType` property.
    pub object_type: &'gc Node<'gc>,
    /// ESTree `indexType` property.
    pub index_type: &'gc Node<'gc>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
}
impl<'gc> OptionalIndexedAccessType<'gc> {
    /// Build `OptionalIndexedAccessType` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        object_type: &'gc Node<'gc>,
        index_type: &'gc Node<'gc>,
        optional: bool,
    ) -> Self {
        OptionalIndexedAccessType {
            metadata,
            object_type,
            index_type,
            optional: Cell::new(optional),
        }
    }
}

/// The `ConditionalTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ConditionalTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `checkType` property.
    pub check_type: &'gc Node<'gc>,
    /// ESTree `extendsType` property.
    pub extends_type: &'gc Node<'gc>,
    /// ESTree `trueType` property.
    pub true_type: &'gc Node<'gc>,
    /// ESTree `falseType` property.
    pub false_type: &'gc Node<'gc>,
}
impl<'gc> ConditionalTypeAnnotation<'gc> {
    /// Build `ConditionalTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        check_type: &'gc Node<'gc>,
        extends_type: &'gc Node<'gc>,
        true_type: &'gc Node<'gc>,
        false_type: &'gc Node<'gc>,
    ) -> Self {
        ConditionalTypeAnnotation {
            metadata,
            check_type,
            extends_type,
            true_type,
            false_type,
        }
    }
}

/// The `TypePredicate` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TypePredicate<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `parameterName` property.
    pub parameter_name: &'gc Node<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: Option<&'gc Node<'gc>>,
    /// ESTree `kind` property.
    pub kind: Cell<NodeString>,
}
impl<'gc> TypePredicate<'gc> {
    /// Build `TypePredicate` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        parameter_name: &'gc Node<'gc>,
        type_annotation: Option<&'gc Node<'gc>>,
        kind: NodeString,
    ) -> Self {
        TypePredicate {
            metadata,
            parameter_name,
            type_annotation,
            kind: Cell::new(kind),
        }
    }
    /// The `kind` string value as UTF-8, or `None` if it has no UTF-8 form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `kind_str`: an unrepresentable identifier
    /// means something is broken, but an unrepresentable string literal is
    /// legal JS, and a codegen or refactoring tool that let U+FFFD be
    /// substituted here would silently rewrite the user's program. Reach for
    /// [`Self::kind_str_lossy`] only when a best-effort rendering is what you
    /// want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.kind.get())
    }
    /// The `kind` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_kind_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn kind_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.kind.get())
    }
}

/// The `InterfaceTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct InterfaceTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `extends` property.
    pub extends: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: Option<&'gc Node<'gc>>,
}
impl<'gc> InterfaceTypeAnnotation<'gc> {
    /// Build `InterfaceTypeAnnotation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        extends: NodeList<'gc>,
        body: Option<&'gc Node<'gc>>,
    ) -> Self {
        InterfaceTypeAnnotation {
            metadata,
            extends,
            body,
        }
    }
}

/// The `TypeAlias` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TypeAlias<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `right` property.
    pub right: &'gc Node<'gc>,
}
impl<'gc> TypeAlias<'gc> {
    /// Build `TypeAlias` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        right: &'gc Node<'gc>,
    ) -> Self {
        TypeAlias {
            metadata,
            id,
            type_parameters,
            right,
        }
    }
}

/// The `OpaqueType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct OpaqueType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `impltype` property.
    pub impltype: &'gc Node<'gc>,
    /// ESTree `lowerBound` property.
    pub lower_bound: Option<&'gc Node<'gc>>,
    /// ESTree `upperBound` property.
    pub upper_bound: Option<&'gc Node<'gc>>,
    /// ESTree `supertype` property.
    pub supertype: Option<&'gc Node<'gc>>,
}
impl<'gc> OpaqueType<'gc> {
    /// Build `OpaqueType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        impltype: &'gc Node<'gc>,
        lower_bound: Option<&'gc Node<'gc>>,
        upper_bound: Option<&'gc Node<'gc>>,
        supertype: Option<&'gc Node<'gc>>,
    ) -> Self {
        OpaqueType {
            metadata,
            id,
            type_parameters,
            impltype,
            lower_bound,
            upper_bound,
            supertype,
        }
    }
}

/// The `InterfaceDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct InterfaceDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `extends` property.
    pub extends: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> InterfaceDeclaration<'gc> {
    /// Build `InterfaceDeclaration` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        extends: NodeList<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        InterfaceDeclaration {
            metadata,
            id,
            type_parameters,
            extends,
            body,
        }
    }
}

/// The `DeclareTypeAlias` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareTypeAlias<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `right` property.
    pub right: &'gc Node<'gc>,
}
impl<'gc> DeclareTypeAlias<'gc> {
    /// Build `DeclareTypeAlias` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        right: &'gc Node<'gc>,
    ) -> Self {
        DeclareTypeAlias {
            metadata,
            id,
            type_parameters,
            right,
        }
    }
}

/// The `DeclareOpaqueType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareOpaqueType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `impltype` property.
    pub impltype: Option<&'gc Node<'gc>>,
    /// ESTree `lowerBound` property.
    pub lower_bound: Option<&'gc Node<'gc>>,
    /// ESTree `upperBound` property.
    pub upper_bound: Option<&'gc Node<'gc>>,
    /// ESTree `supertype` property.
    pub supertype: Option<&'gc Node<'gc>>,
}
impl<'gc> DeclareOpaqueType<'gc> {
    /// Build `DeclareOpaqueType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        impltype: Option<&'gc Node<'gc>>,
        lower_bound: Option<&'gc Node<'gc>>,
        upper_bound: Option<&'gc Node<'gc>>,
        supertype: Option<&'gc Node<'gc>>,
    ) -> Self {
        DeclareOpaqueType {
            metadata,
            id,
            type_parameters,
            impltype,
            lower_bound,
            upper_bound,
            supertype,
        }
    }
}

/// The `DeclareInterface` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareInterface<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `extends` property.
    pub extends: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> DeclareInterface<'gc> {
    /// Build `DeclareInterface` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        extends: NodeList<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        DeclareInterface {
            metadata,
            id,
            type_parameters,
            extends,
            body,
        }
    }
}

/// The `DeclareClass` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareClass<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `extends` property.
    pub extends: NodeList<'gc>,
    /// ESTree `implements` property.
    pub implements: NodeList<'gc>,
    /// ESTree `mixins` property.
    pub mixins: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> DeclareClass<'gc> {
    /// Build `DeclareClass` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        extends: NodeList<'gc>,
        implements: NodeList<'gc>,
        mixins: NodeList<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        DeclareClass {
            metadata,
            id,
            type_parameters,
            extends,
            implements,
            mixins,
            body,
        }
    }
}

/// The `DeclareFunction` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareFunction<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `predicate` property.
    pub predicate: Option<&'gc Node<'gc>>,
}
impl<'gc> DeclareFunction<'gc> {
    /// Build `DeclareFunction` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        predicate: Option<&'gc Node<'gc>>,
    ) -> Self {
        DeclareFunction {
            metadata,
            id,
            predicate,
        }
    }
}

/// The `DeclareHook` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareHook<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
}
impl<'gc> DeclareHook<'gc> {
    /// Build `DeclareHook` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
    ) -> Self {
        DeclareHook {
            metadata,
            id,
        }
    }
}

/// The `DeclareComponent` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareComponent<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `rest` property.
    pub rest: Option<&'gc Node<'gc>>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `rendersType` property.
    pub renders_type: Option<&'gc Node<'gc>>,
}
impl<'gc> DeclareComponent<'gc> {
    /// Build `DeclareComponent` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        params: NodeList<'gc>,
        rest: Option<&'gc Node<'gc>>,
        type_parameters: Option<&'gc Node<'gc>>,
        renders_type: Option<&'gc Node<'gc>>,
    ) -> Self {
        DeclareComponent {
            metadata,
            id,
            params,
            rest,
            type_parameters,
            renders_type,
        }
    }
}

/// The `DeclareVariable` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareVariable<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `kind` property.
    pub kind: Cell<NodeLabel>,
}
impl<'gc> DeclareVariable<'gc> {
    /// Build `DeclareVariable` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        kind: NodeLabel,
    ) -> Self {
        DeclareVariable {
            metadata,
            id,
            kind: Cell::new(kind),
        }
    }
    /// The `kind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.kind.get())
    }
}

/// The `DeclareEnum` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareEnum<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> DeclareEnum<'gc> {
    /// Build `DeclareEnum` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        DeclareEnum {
            metadata,
            id,
            body,
        }
    }
}

/// The `DeclareExportDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareExportDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `declaration` property.
    pub declaration: Option<&'gc Node<'gc>>,
    /// ESTree `specifiers` property.
    pub specifiers: NodeList<'gc>,
    /// ESTree `source` property.
    pub source: Option<&'gc Node<'gc>>,
    /// ESTree `default` property.
    pub default: Cell<bool>,
}
impl<'gc> DeclareExportDeclaration<'gc> {
    /// Build `DeclareExportDeclaration` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        declaration: Option<&'gc Node<'gc>>,
        specifiers: NodeList<'gc>,
        source: Option<&'gc Node<'gc>>,
        default: bool,
    ) -> Self {
        DeclareExportDeclaration {
            metadata,
            declaration,
            specifiers,
            source,
            default: Cell::new(default),
        }
    }
}

/// The `DeclareExportAllDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareExportAllDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `source` property.
    pub source: &'gc Node<'gc>,
}
impl<'gc> DeclareExportAllDeclaration<'gc> {
    /// Build `DeclareExportAllDeclaration` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        source: &'gc Node<'gc>,
    ) -> Self {
        DeclareExportAllDeclaration {
            metadata,
            source,
        }
    }
}

/// The `DeclareModule` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareModule<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> DeclareModule<'gc> {
    /// Build `DeclareModule` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        DeclareModule {
            metadata,
            id,
            body,
        }
    }
}

/// The `DeclareNamespace` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareNamespace<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> DeclareNamespace<'gc> {
    /// Build `DeclareNamespace` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        DeclareNamespace {
            metadata,
            id,
            body,
        }
    }
}

/// The `DeclareModuleExports` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclareModuleExports<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> DeclareModuleExports<'gc> {
    /// Build `DeclareModuleExports` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        DeclareModuleExports {
            metadata,
            type_annotation,
        }
    }
}

/// The `InterfaceExtends` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct InterfaceExtends<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> InterfaceExtends<'gc> {
    /// Build `InterfaceExtends` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        InterfaceExtends {
            metadata,
            id,
            type_parameters,
        }
    }
}

/// The `ClassImplements` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ClassImplements<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> ClassImplements<'gc> {
    /// Build `ClassImplements` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        ClassImplements {
            metadata,
            id,
            type_parameters,
        }
    }
}

/// The `TypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> TypeAnnotation<'gc> {
    /// Build `TypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        TypeAnnotation {
            metadata,
            type_annotation,
        }
    }
}

/// The `ObjectTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ObjectTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `properties` property.
    pub properties: NodeList<'gc>,
    /// ESTree `indexers` property.
    pub indexers: NodeList<'gc>,
    /// ESTree `callProperties` property.
    pub call_properties: NodeList<'gc>,
    /// ESTree `internalSlots` property.
    pub internal_slots: NodeList<'gc>,
    /// ESTree `inexact` property.
    pub inexact: Cell<bool>,
    /// ESTree `exact` property.
    pub exact: Cell<bool>,
}
impl<'gc> ObjectTypeAnnotation<'gc> {
    /// Build `ObjectTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        properties: NodeList<'gc>,
        indexers: NodeList<'gc>,
        call_properties: NodeList<'gc>,
        internal_slots: NodeList<'gc>,
        inexact: bool,
        exact: bool,
    ) -> Self {
        ObjectTypeAnnotation {
            metadata,
            properties,
            indexers,
            call_properties,
            internal_slots,
            inexact: Cell::new(inexact),
            exact: Cell::new(exact),
        }
    }
}

/// The `ObjectTypeProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ObjectTypeProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
    /// ESTree `method` property.
    pub method: Cell<bool>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
    /// ESTree `static` property.
    pub r#static: Cell<bool>,
    /// ESTree `proto` property.
    pub proto: Cell<bool>,
    /// ESTree `variance` property.
    pub variance: Option<&'gc Node<'gc>>,
    /// ESTree `kind` property.
    pub kind: Cell<NodeLabel>,
}
impl<'gc> ObjectTypeProperty<'gc> {
    /// Build `ObjectTypeProperty` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        value: &'gc Node<'gc>,
        method: bool,
        optional: bool,
        r#static: bool,
        proto: bool,
        variance: Option<&'gc Node<'gc>>,
        kind: NodeLabel,
    ) -> Self {
        ObjectTypeProperty {
            metadata,
            key,
            value,
            method: Cell::new(method),
            optional: Cell::new(optional),
            r#static: Cell::new(r#static),
            proto: Cell::new(proto),
            variance,
            kind: Cell::new(kind),
        }
    }
    /// The `kind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.kind.get())
    }
}

/// The `ObjectTypeSpreadProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ObjectTypeSpreadProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
}
impl<'gc> ObjectTypeSpreadProperty<'gc> {
    /// Build `ObjectTypeSpreadProperty` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
    ) -> Self {
        ObjectTypeSpreadProperty {
            metadata,
            argument,
        }
    }
}

/// The `ObjectTypeInternalSlot` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ObjectTypeInternalSlot<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
    /// ESTree `static` property.
    pub r#static: Cell<bool>,
    /// ESTree `method` property.
    pub method: Cell<bool>,
}
impl<'gc> ObjectTypeInternalSlot<'gc> {
    /// Build `ObjectTypeInternalSlot` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        value: &'gc Node<'gc>,
        optional: bool,
        r#static: bool,
        method: bool,
    ) -> Self {
        ObjectTypeInternalSlot {
            metadata,
            id,
            value,
            optional: Cell::new(optional),
            r#static: Cell::new(r#static),
            method: Cell::new(method),
        }
    }
}

/// The `ObjectTypeCallProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ObjectTypeCallProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
    /// ESTree `static` property.
    pub r#static: Cell<bool>,
}
impl<'gc> ObjectTypeCallProperty<'gc> {
    /// Build `ObjectTypeCallProperty` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: &'gc Node<'gc>,
        r#static: bool,
    ) -> Self {
        ObjectTypeCallProperty {
            metadata,
            value,
            r#static: Cell::new(r#static),
        }
    }
}

/// The `ObjectTypeIndexer` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ObjectTypeIndexer<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: Option<&'gc Node<'gc>>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
    /// ESTree `static` property.
    pub r#static: Cell<bool>,
    /// ESTree `variance` property.
    pub variance: Option<&'gc Node<'gc>>,
}
impl<'gc> ObjectTypeIndexer<'gc> {
    /// Build `ObjectTypeIndexer` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: Option<&'gc Node<'gc>>,
        key: &'gc Node<'gc>,
        value: &'gc Node<'gc>,
        r#static: bool,
        variance: Option<&'gc Node<'gc>>,
    ) -> Self {
        ObjectTypeIndexer {
            metadata,
            id,
            key,
            value,
            r#static: Cell::new(r#static),
            variance,
        }
    }
}

/// The `ObjectTypeMappedTypeProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ObjectTypeMappedTypeProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `keyTparam` property.
    pub key_tparam: &'gc Node<'gc>,
    /// ESTree `propType` property.
    pub prop_type: &'gc Node<'gc>,
    /// ESTree `sourceType` property.
    pub source_type: &'gc Node<'gc>,
    /// ESTree `variance` property.
    pub variance: Option<&'gc Node<'gc>>,
    /// ESTree `optional` property.
    pub optional: Cell<NodeString>,
}
impl<'gc> ObjectTypeMappedTypeProperty<'gc> {
    /// Build `ObjectTypeMappedTypeProperty` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key_tparam: &'gc Node<'gc>,
        prop_type: &'gc Node<'gc>,
        source_type: &'gc Node<'gc>,
        variance: Option<&'gc Node<'gc>>,
        optional: NodeString,
    ) -> Self {
        ObjectTypeMappedTypeProperty {
            metadata,
            key_tparam,
            prop_type,
            source_type,
            variance,
            optional: Cell::new(optional),
        }
    }
    /// The `optional` string value as UTF-8, or `None` if it has no UTF-8 form.
    ///
    /// A JS string value is a sequence of UTF-16 code units, so it may legally
    /// contain an *unpaired* surrogate (`"\uD800"` parses, and is not an
    /// error). That, and only that, is what `None` reports: the value is
    /// intact, it simply cannot be spelled in UTF-8. Read it losslessly with
    /// [`GCLock::bytes`](crate::context::GCLock::bytes).
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal yields `Some("😀")`, not `None`.
    ///
    /// There is deliberately no plain `optional_str`: an unrepresentable
    /// identifier means something is broken, but an unrepresentable string
    /// literal is legal JS, and a codegen or refactoring tool that let U+FFFD
    /// be substituted here would silently rewrite the user's program. Reach for
    /// [`Self::optional_str_lossy`] only when a best-effort rendering is what
    /// you want.
    ///
    /// Valid UTF-8 is borrowed from the atom's own bytes and allocates nothing;
    /// folding a surrogate pair allocates once per atom, cached in the context.
    /// The returned `&str` borrows from `gc`, not from `self`.
    pub fn try_optional_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> Option<&'a str> {
        gc.try_bytes_str(self.optional.get())
    }
    /// The `optional` string value as UTF-8, substituting U+FFFD for anything
    /// unrepresentable.
    ///
    /// **This is lossy.** A JS string value may legally contain an unpaired
    /// surrogate (`"\uD800"` parses), which has no UTF-8 form; each one becomes
    /// exactly one U+FFFD here. Do not use this to re-emit source: a codegen or
    /// refactoring tool would silently rewrite the user's program.
    ///
    /// Only an *unpaired* surrogate is unrepresentable. A WTF-8 surrogate
    /// *pair* is not: the lexer interns an astral character in surrogate-pair
    /// form, and it is folded back into the character it encodes, so a `"😀"`
    /// literal comes out intact.
    ///
    /// Use [`Self::try_optional_str`] or
    /// [`GCLock::bytes`](crate::context::GCLock::bytes) when the exact value
    /// matters. The returned `&str` borrows from `gc`, not from `self`.
    pub fn optional_str_lossy<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.optional.get())
    }
}

/// The `Variance` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct Variance<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `kind` property.
    pub kind: Cell<NodeLabel>,
}
impl<'gc> Variance<'gc> {
    /// Build `Variance` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        kind: NodeLabel,
    ) -> Self {
        Variance {
            metadata,
            kind: Cell::new(kind),
        }
    }
    /// The `kind` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn kind_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.kind.get())
    }
}

/// The `TypeParameterDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TypeParameterDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
}
impl<'gc> TypeParameterDeclaration<'gc> {
    /// Build `TypeParameterDeclaration` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
    ) -> Self {
        TypeParameterDeclaration {
            metadata,
            params,
        }
    }
}

/// The `TypeParameter` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TypeParameter<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: Cell<NodeLabel>,
    /// ESTree `const` property.
    pub r#const: Cell<bool>,
    /// ESTree `bound` property.
    pub bound: Option<&'gc Node<'gc>>,
    /// ESTree `variance` property.
    pub variance: Option<&'gc Node<'gc>>,
    /// ESTree `default` property.
    pub default: Option<&'gc Node<'gc>>,
    /// ESTree `usesExtendsBound` property.
    pub uses_extends_bound: Cell<bool>,
}
impl<'gc> TypeParameter<'gc> {
    /// Build `TypeParameter` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: NodeLabel,
        r#const: bool,
        bound: Option<&'gc Node<'gc>>,
        variance: Option<&'gc Node<'gc>>,
        default: Option<&'gc Node<'gc>>,
        uses_extends_bound: bool,
    ) -> Self {
        TypeParameter {
            metadata,
            name: Cell::new(name),
            r#const: Cell::new(r#const),
            bound,
            variance,
            default,
            uses_extends_bound: Cell::new(uses_extends_bound),
        }
    }
    /// The `name` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn name_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.name.get())
    }
}

/// The `TypeParameterInstantiation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TypeParameterInstantiation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
}
impl<'gc> TypeParameterInstantiation<'gc> {
    /// Build `TypeParameterInstantiation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
    ) -> Self {
        TypeParameterInstantiation {
            metadata,
            params,
        }
    }
}

/// The `TypeCastExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TypeCastExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> TypeCastExpression<'gc> {
    /// Build `TypeCastExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expression: &'gc Node<'gc>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        TypeCastExpression {
            metadata,
            expression,
            type_annotation,
        }
    }
}

/// The `AsExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct AsExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> AsExpression<'gc> {
    /// Build `AsExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expression: &'gc Node<'gc>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        AsExpression {
            metadata,
            expression,
            type_annotation,
        }
    }
}

/// The `AsConstExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct AsConstExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
}
impl<'gc> AsConstExpression<'gc> {
    /// Build `AsConstExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expression: &'gc Node<'gc>,
    ) -> Self {
        AsConstExpression {
            metadata,
            expression,
        }
    }
}

/// The `InferredPredicate` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct InferredPredicate<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> InferredPredicate<'gc> {
    /// Build `InferredPredicate` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        InferredPredicate {
            metadata,
        }
    }
}

/// The `DeclaredPredicate` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct DeclaredPredicate<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
}
impl<'gc> DeclaredPredicate<'gc> {
    /// Build `DeclaredPredicate` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        value: &'gc Node<'gc>,
    ) -> Self {
        DeclaredPredicate {
            metadata,
            value,
        }
    }
}

/// The `EnumDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> EnumDeclaration<'gc> {
    /// Build `EnumDeclaration` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        EnumDeclaration {
            metadata,
            id,
            body,
        }
    }
}

/// The `EnumStringBody` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumStringBody<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `members` property.
    pub members: NodeList<'gc>,
    /// ESTree `explicitType` property.
    pub explicit_type: Cell<bool>,
    /// ESTree `hasUnknownMembers` property.
    pub has_unknown_members: Cell<bool>,
}
impl<'gc> EnumStringBody<'gc> {
    /// Build `EnumStringBody` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        members: NodeList<'gc>,
        explicit_type: bool,
        has_unknown_members: bool,
    ) -> Self {
        EnumStringBody {
            metadata,
            members,
            explicit_type: Cell::new(explicit_type),
            has_unknown_members: Cell::new(has_unknown_members),
        }
    }
}

/// The `EnumNumberBody` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumNumberBody<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `members` property.
    pub members: NodeList<'gc>,
    /// ESTree `explicitType` property.
    pub explicit_type: Cell<bool>,
    /// ESTree `hasUnknownMembers` property.
    pub has_unknown_members: Cell<bool>,
}
impl<'gc> EnumNumberBody<'gc> {
    /// Build `EnumNumberBody` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        members: NodeList<'gc>,
        explicit_type: bool,
        has_unknown_members: bool,
    ) -> Self {
        EnumNumberBody {
            metadata,
            members,
            explicit_type: Cell::new(explicit_type),
            has_unknown_members: Cell::new(has_unknown_members),
        }
    }
}

/// The `EnumBigIntBody` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumBigIntBody<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `members` property.
    pub members: NodeList<'gc>,
    /// ESTree `explicitType` property.
    pub explicit_type: Cell<bool>,
    /// ESTree `hasUnknownMembers` property.
    pub has_unknown_members: Cell<bool>,
}
impl<'gc> EnumBigIntBody<'gc> {
    /// Build `EnumBigIntBody` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        members: NodeList<'gc>,
        explicit_type: bool,
        has_unknown_members: bool,
    ) -> Self {
        EnumBigIntBody {
            metadata,
            members,
            explicit_type: Cell::new(explicit_type),
            has_unknown_members: Cell::new(has_unknown_members),
        }
    }
}

/// The `EnumBooleanBody` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumBooleanBody<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `members` property.
    pub members: NodeList<'gc>,
    /// ESTree `explicitType` property.
    pub explicit_type: Cell<bool>,
    /// ESTree `hasUnknownMembers` property.
    pub has_unknown_members: Cell<bool>,
}
impl<'gc> EnumBooleanBody<'gc> {
    /// Build `EnumBooleanBody` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        members: NodeList<'gc>,
        explicit_type: bool,
        has_unknown_members: bool,
    ) -> Self {
        EnumBooleanBody {
            metadata,
            members,
            explicit_type: Cell::new(explicit_type),
            has_unknown_members: Cell::new(has_unknown_members),
        }
    }
}

/// The `EnumSymbolBody` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumSymbolBody<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `members` property.
    pub members: NodeList<'gc>,
    /// ESTree `hasUnknownMembers` property.
    pub has_unknown_members: Cell<bool>,
}
impl<'gc> EnumSymbolBody<'gc> {
    /// Build `EnumSymbolBody` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        members: NodeList<'gc>,
        has_unknown_members: bool,
    ) -> Self {
        EnumSymbolBody {
            metadata,
            members,
            has_unknown_members: Cell::new(has_unknown_members),
        }
    }
}

/// The `EnumDefaultedMember` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumDefaultedMember<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
}
impl<'gc> EnumDefaultedMember<'gc> {
    /// Build `EnumDefaultedMember` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
    ) -> Self {
        EnumDefaultedMember {
            metadata,
            id,
        }
    }
}

/// The `EnumStringMember` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumStringMember<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `init` property.
    pub init: &'gc Node<'gc>,
}
impl<'gc> EnumStringMember<'gc> {
    /// Build `EnumStringMember` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        init: &'gc Node<'gc>,
    ) -> Self {
        EnumStringMember {
            metadata,
            id,
            init,
        }
    }
}

/// The `EnumNumberMember` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumNumberMember<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `init` property.
    pub init: &'gc Node<'gc>,
}
impl<'gc> EnumNumberMember<'gc> {
    /// Build `EnumNumberMember` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        init: &'gc Node<'gc>,
    ) -> Self {
        EnumNumberMember {
            metadata,
            id,
            init,
        }
    }
}

/// The `EnumBigIntMember` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumBigIntMember<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `init` property.
    pub init: &'gc Node<'gc>,
}
impl<'gc> EnumBigIntMember<'gc> {
    /// Build `EnumBigIntMember` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        init: &'gc Node<'gc>,
    ) -> Self {
        EnumBigIntMember {
            metadata,
            id,
            init,
        }
    }
}

/// The `EnumBooleanMember` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct EnumBooleanMember<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `init` property.
    pub init: &'gc Node<'gc>,
}
impl<'gc> EnumBooleanMember<'gc> {
    /// Build `EnumBooleanMember` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        init: &'gc Node<'gc>,
    ) -> Self {
        EnumBooleanMember {
            metadata,
            id,
            init,
        }
    }
}

/// The `ComponentParameter` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ComponentParameter<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: &'gc Node<'gc>,
    /// ESTree `local` property.
    pub local: &'gc Node<'gc>,
    /// ESTree `shorthand` property.
    pub shorthand: Cell<bool>,
}
impl<'gc> ComponentParameter<'gc> {
    /// Build `ComponentParameter` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: &'gc Node<'gc>,
        local: &'gc Node<'gc>,
        shorthand: bool,
    ) -> Self {
        ComponentParameter {
            metadata,
            name,
            local,
            shorthand: Cell::new(shorthand),
        }
    }
}

/// The `RecordDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct RecordDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `implements` property.
    pub implements: NodeList<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> RecordDeclaration<'gc> {
    /// Build `RecordDeclaration` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        implements: NodeList<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        RecordDeclaration {
            metadata,
            id,
            type_parameters,
            implements,
            body,
        }
    }
}

/// The `RecordDeclarationImplements` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct RecordDeclarationImplements<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeArguments` property.
    pub type_arguments: Option<&'gc Node<'gc>>,
}
impl<'gc> RecordDeclarationImplements<'gc> {
    /// Build `RecordDeclarationImplements` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_arguments: Option<&'gc Node<'gc>>,
    ) -> Self {
        RecordDeclarationImplements {
            metadata,
            id,
            type_arguments,
        }
    }
}

/// The `RecordDeclarationBody` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct RecordDeclarationBody<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `elements` property.
    pub elements: NodeList<'gc>,
}
impl<'gc> RecordDeclarationBody<'gc> {
    /// Build `RecordDeclarationBody` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        elements: NodeList<'gc>,
    ) -> Self {
        RecordDeclarationBody {
            metadata,
            elements,
        }
    }
}

/// The `RecordDeclarationProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct RecordDeclarationProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
    /// ESTree `defaultValue` property.
    pub default_value: Option<&'gc Node<'gc>>,
}
impl<'gc> RecordDeclarationProperty<'gc> {
    /// Build `RecordDeclarationProperty` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        type_annotation: &'gc Node<'gc>,
        default_value: Option<&'gc Node<'gc>>,
    ) -> Self {
        RecordDeclarationProperty {
            metadata,
            key,
            type_annotation,
            default_value,
        }
    }
}

/// The `RecordDeclarationStaticProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct RecordDeclarationStaticProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
    /// ESTree `value` property.
    pub value: &'gc Node<'gc>,
}
impl<'gc> RecordDeclarationStaticProperty<'gc> {
    /// Build `RecordDeclarationStaticProperty` from its metadata and
    /// `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        type_annotation: &'gc Node<'gc>,
        value: &'gc Node<'gc>,
    ) -> Self {
        RecordDeclarationStaticProperty {
            metadata,
            key,
            type_annotation,
            value,
        }
    }
}

/// The `RecordExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct RecordExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `recordConstructor` property.
    pub record_constructor: &'gc Node<'gc>,
    /// ESTree `typeArguments` property.
    pub type_arguments: Option<&'gc Node<'gc>>,
    /// ESTree `properties` property.
    pub properties: &'gc Node<'gc>,
}
impl<'gc> RecordExpression<'gc> {
    /// Build `RecordExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        record_constructor: &'gc Node<'gc>,
        type_arguments: Option<&'gc Node<'gc>>,
        properties: &'gc Node<'gc>,
    ) -> Self {
        RecordExpression {
            metadata,
            record_constructor,
            type_arguments,
            properties,
        }
    }
}

/// The `RecordExpressionProperties` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct RecordExpressionProperties<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `properties` property.
    pub properties: NodeList<'gc>,
}
impl<'gc> RecordExpressionProperties<'gc> {
    /// Build `RecordExpressionProperties` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        properties: NodeList<'gc>,
    ) -> Self {
        RecordExpressionProperties {
            metadata,
            properties,
        }
    }
}

/// The `TSTypeAnnotation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypeAnnotation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> TSTypeAnnotation<'gc> {
    /// Build `TSTypeAnnotation` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        TSTypeAnnotation {
            metadata,
            type_annotation,
        }
    }
}

/// The `TSAnyKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSAnyKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSAnyKeyword<'gc> {
    /// Build `TSAnyKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSAnyKeyword {
            metadata,
        }
    }
}

/// The `TSNumberKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSNumberKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSNumberKeyword<'gc> {
    /// Build `TSNumberKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSNumberKeyword {
            metadata,
        }
    }
}

/// The `TSBooleanKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSBooleanKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSBooleanKeyword<'gc> {
    /// Build `TSBooleanKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSBooleanKeyword {
            metadata,
        }
    }
}

/// The `TSStringKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSStringKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSStringKeyword<'gc> {
    /// Build `TSStringKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSStringKeyword {
            metadata,
        }
    }
}

/// The `TSSymbolKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSSymbolKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSSymbolKeyword<'gc> {
    /// Build `TSSymbolKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSSymbolKeyword {
            metadata,
        }
    }
}

/// The `TSVoidKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSVoidKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSVoidKeyword<'gc> {
    /// Build `TSVoidKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSVoidKeyword {
            metadata,
        }
    }
}

/// The `TSUndefinedKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSUndefinedKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSUndefinedKeyword<'gc> {
    /// Build `TSUndefinedKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSUndefinedKeyword {
            metadata,
        }
    }
}

/// The `TSUnknownKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSUnknownKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSUnknownKeyword<'gc> {
    /// Build `TSUnknownKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSUnknownKeyword {
            metadata,
        }
    }
}

/// The `TSNeverKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSNeverKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSNeverKeyword<'gc> {
    /// Build `TSNeverKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSNeverKeyword {
            metadata,
        }
    }
}

/// The `TSBigIntKeyword` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSBigIntKeyword<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSBigIntKeyword<'gc> {
    /// Build `TSBigIntKeyword` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSBigIntKeyword {
            metadata,
        }
    }
}

/// The `TSThisType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSThisType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> TSThisType<'gc> {
    /// Build `TSThisType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        TSThisType {
            metadata,
        }
    }
}

/// The `TSLiteralType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSLiteralType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `literal` property.
    pub literal: &'gc Node<'gc>,
}
impl<'gc> TSLiteralType<'gc> {
    /// Build `TSLiteralType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        literal: &'gc Node<'gc>,
    ) -> Self {
        TSLiteralType {
            metadata,
            literal,
        }
    }
}

/// The `TSIndexedAccessType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSIndexedAccessType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `objectType` property.
    pub object_type: &'gc Node<'gc>,
    /// ESTree `indexType` property.
    pub index_type: &'gc Node<'gc>,
}
impl<'gc> TSIndexedAccessType<'gc> {
    /// Build `TSIndexedAccessType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        object_type: &'gc Node<'gc>,
        index_type: &'gc Node<'gc>,
    ) -> Self {
        TSIndexedAccessType {
            metadata,
            object_type,
            index_type,
        }
    }
}

/// The `TSArrayType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSArrayType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `elementType` property.
    pub element_type: &'gc Node<'gc>,
}
impl<'gc> TSArrayType<'gc> {
    /// Build `TSArrayType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        element_type: &'gc Node<'gc>,
    ) -> Self {
        TSArrayType {
            metadata,
            element_type,
        }
    }
}

/// The `TSTypeReference` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypeReference<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `typeName` property.
    pub type_name: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> TSTypeReference<'gc> {
    /// Build `TSTypeReference` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        type_name: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSTypeReference {
            metadata,
            type_name,
            type_parameters,
        }
    }
}

/// The `TSQualifiedName` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSQualifiedName<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `left` property.
    pub left: &'gc Node<'gc>,
    /// ESTree `right` property.
    pub right: Option<&'gc Node<'gc>>,
}
impl<'gc> TSQualifiedName<'gc> {
    /// Build `TSQualifiedName` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        left: &'gc Node<'gc>,
        right: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSQualifiedName {
            metadata,
            left,
            right,
        }
    }
}

/// The `TSFunctionType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSFunctionType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `returnType` property.
    pub return_type: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> TSFunctionType<'gc> {
    /// Build `TSFunctionType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
        return_type: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSFunctionType {
            metadata,
            params,
            return_type,
            type_parameters,
        }
    }
}

/// The `TSConstructorType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSConstructorType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `returnType` property.
    pub return_type: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> TSConstructorType<'gc> {
    /// Build `TSConstructorType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
        return_type: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSConstructorType {
            metadata,
            params,
            return_type,
            type_parameters,
        }
    }
}

/// The `TSTypePredicate` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypePredicate<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `parameterName` property.
    pub parameter_name: &'gc Node<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> TSTypePredicate<'gc> {
    /// Build `TSTypePredicate` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        parameter_name: &'gc Node<'gc>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        TSTypePredicate {
            metadata,
            parameter_name,
            type_annotation,
        }
    }
}

/// The `TSTupleType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTupleType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `elementTypes` property.
    pub element_types: NodeList<'gc>,
}
impl<'gc> TSTupleType<'gc> {
    /// Build `TSTupleType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        element_types: NodeList<'gc>,
    ) -> Self {
        TSTupleType {
            metadata,
            element_types,
        }
    }
}

/// The `TSTypeAssertion` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypeAssertion<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
}
impl<'gc> TSTypeAssertion<'gc> {
    /// Build `TSTypeAssertion` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        type_annotation: &'gc Node<'gc>,
        expression: &'gc Node<'gc>,
    ) -> Self {
        TSTypeAssertion {
            metadata,
            type_annotation,
            expression,
        }
    }
}

/// The `TSAsExpression` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSAsExpression<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> TSAsExpression<'gc> {
    /// Build `TSAsExpression` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expression: &'gc Node<'gc>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        TSAsExpression {
            metadata,
            expression,
            type_annotation,
        }
    }
}

/// The `TSParameterProperty` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSParameterProperty<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `parameter` property.
    pub parameter: &'gc Node<'gc>,
    /// ESTree `accessibility` property.
    pub accessibility: Cell<NodeLabel>,
    /// ESTree `readonly` property.
    pub readonly: Cell<bool>,
    /// ESTree `static` property.
    pub r#static: Cell<bool>,
    /// ESTree `export` property.
    pub export: Cell<bool>,
}
impl<'gc> TSParameterProperty<'gc> {
    /// Build `TSParameterProperty` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        parameter: &'gc Node<'gc>,
        accessibility: NodeLabel,
        readonly: bool,
        r#static: bool,
        export: bool,
    ) -> Self {
        TSParameterProperty {
            metadata,
            parameter,
            accessibility: Cell::new(accessibility),
            readonly: Cell::new(readonly),
            r#static: Cell::new(r#static),
            export: Cell::new(export),
        }
    }
    /// The `accessibility` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn accessibility_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.accessibility.get())
    }
}

/// The `TSTypeAliasDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypeAliasDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: &'gc Node<'gc>,
}
impl<'gc> TSTypeAliasDeclaration<'gc> {
    /// Build `TSTypeAliasDeclaration` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
        type_annotation: &'gc Node<'gc>,
    ) -> Self {
        TSTypeAliasDeclaration {
            metadata,
            id,
            type_parameters,
            type_annotation,
        }
    }
}

/// The `TSInterfaceDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSInterfaceDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
    /// ESTree `extends` property.
    pub extends: NodeList<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> TSInterfaceDeclaration<'gc> {
    /// Build `TSInterfaceDeclaration` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
        extends: NodeList<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSInterfaceDeclaration {
            metadata,
            id,
            body,
            extends,
            type_parameters,
        }
    }
}

/// The `TSInterfaceHeritage` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSInterfaceHeritage<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `expression` property.
    pub expression: &'gc Node<'gc>,
    /// ESTree `typeParameters` property.
    pub type_parameters: Option<&'gc Node<'gc>>,
}
impl<'gc> TSInterfaceHeritage<'gc> {
    /// Build `TSInterfaceHeritage` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expression: &'gc Node<'gc>,
        type_parameters: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSInterfaceHeritage {
            metadata,
            expression,
            type_parameters,
        }
    }
}

/// The `TSInterfaceBody` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSInterfaceBody<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `body` property.
    pub body: NodeList<'gc>,
}
impl<'gc> TSInterfaceBody<'gc> {
    /// Build `TSInterfaceBody` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        body: NodeList<'gc>,
    ) -> Self {
        TSInterfaceBody {
            metadata,
            body,
        }
    }
}

/// The `TSEnumDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSEnumDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `members` property.
    pub members: NodeList<'gc>,
}
impl<'gc> TSEnumDeclaration<'gc> {
    /// Build `TSEnumDeclaration` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        members: NodeList<'gc>,
    ) -> Self {
        TSEnumDeclaration {
            metadata,
            id,
            members,
        }
    }
}

/// The `TSEnumMember` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSEnumMember<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `initializer` property.
    pub initializer: Option<&'gc Node<'gc>>,
}
impl<'gc> TSEnumMember<'gc> {
    /// Build `TSEnumMember` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        initializer: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSEnumMember {
            metadata,
            id,
            initializer,
        }
    }
}

/// The `TSModuleDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSModuleDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `body` property.
    pub body: &'gc Node<'gc>,
}
impl<'gc> TSModuleDeclaration<'gc> {
    /// Build `TSModuleDeclaration` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        body: &'gc Node<'gc>,
    ) -> Self {
        TSModuleDeclaration {
            metadata,
            id,
            body,
        }
    }
}

/// The `TSModuleBlock` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSModuleBlock<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `body` property.
    pub body: NodeList<'gc>,
}
impl<'gc> TSModuleBlock<'gc> {
    /// Build `TSModuleBlock` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        body: NodeList<'gc>,
    ) -> Self {
        TSModuleBlock {
            metadata,
            body,
        }
    }
}

/// The `TSModuleMember` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSModuleMember<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `id` property.
    pub id: &'gc Node<'gc>,
    /// ESTree `initializer` property.
    pub initializer: Option<&'gc Node<'gc>>,
}
impl<'gc> TSModuleMember<'gc> {
    /// Build `TSModuleMember` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        id: &'gc Node<'gc>,
        initializer: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSModuleMember {
            metadata,
            id,
            initializer,
        }
    }
}

/// The `TSTypeParameterDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypeParameterDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
}
impl<'gc> TSTypeParameterDeclaration<'gc> {
    /// Build `TSTypeParameterDeclaration` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
    ) -> Self {
        TSTypeParameterDeclaration {
            metadata,
            params,
        }
    }
}

/// The `TSTypeParameter` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypeParameter<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `name` property.
    pub name: &'gc Node<'gc>,
    /// ESTree `constraint` property.
    pub constraint: Option<&'gc Node<'gc>>,
    /// ESTree `default` property.
    pub default: Option<&'gc Node<'gc>>,
}
impl<'gc> TSTypeParameter<'gc> {
    /// Build `TSTypeParameter` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        name: &'gc Node<'gc>,
        constraint: Option<&'gc Node<'gc>>,
        default: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSTypeParameter {
            metadata,
            name,
            constraint,
            default,
        }
    }
}

/// The `TSTypeParameterInstantiation` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypeParameterInstantiation<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
}
impl<'gc> TSTypeParameterInstantiation<'gc> {
    /// Build `TSTypeParameterInstantiation` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
    ) -> Self {
        TSTypeParameterInstantiation {
            metadata,
            params,
        }
    }
}

/// The `TSUnionType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSUnionType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `types` property.
    pub types: NodeList<'gc>,
}
impl<'gc> TSUnionType<'gc> {
    /// Build `TSUnionType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        types: NodeList<'gc>,
    ) -> Self {
        TSUnionType {
            metadata,
            types,
        }
    }
}

/// The `TSIntersectionType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSIntersectionType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `types` property.
    pub types: NodeList<'gc>,
}
impl<'gc> TSIntersectionType<'gc> {
    /// Build `TSIntersectionType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        types: NodeList<'gc>,
    ) -> Self {
        TSIntersectionType {
            metadata,
            types,
        }
    }
}

/// The `TSTypeQuery` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypeQuery<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `exprName` property.
    pub expr_name: &'gc Node<'gc>,
}
impl<'gc> TSTypeQuery<'gc> {
    /// Build `TSTypeQuery` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        expr_name: &'gc Node<'gc>,
    ) -> Self {
        TSTypeQuery {
            metadata,
            expr_name,
        }
    }
}

/// The `TSConditionalType` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSConditionalType<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `checkType` property.
    pub check_type: &'gc Node<'gc>,
    /// ESTree `extendsType` property.
    pub extends_type: &'gc Node<'gc>,
    /// ESTree `trueType` property.
    pub true_type: &'gc Node<'gc>,
    /// ESTree `falseType` property.
    pub false_type: &'gc Node<'gc>,
}
impl<'gc> TSConditionalType<'gc> {
    /// Build `TSConditionalType` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        check_type: &'gc Node<'gc>,
        extends_type: &'gc Node<'gc>,
        true_type: &'gc Node<'gc>,
        false_type: &'gc Node<'gc>,
    ) -> Self {
        TSConditionalType {
            metadata,
            check_type,
            extends_type,
            true_type,
            false_type,
        }
    }
}

/// The `TSTypeLiteral` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSTypeLiteral<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `members` property.
    pub members: NodeList<'gc>,
}
impl<'gc> TSTypeLiteral<'gc> {
    /// Build `TSTypeLiteral` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        members: NodeList<'gc>,
    ) -> Self {
        TSTypeLiteral {
            metadata,
            members,
        }
    }
}

/// The `TSPropertySignature` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSPropertySignature<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: Option<&'gc Node<'gc>>,
    /// ESTree `initializer` property.
    pub initializer: Option<&'gc Node<'gc>>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
    /// ESTree `computed` property.
    pub computed: Cell<bool>,
    /// ESTree `readonly` property.
    pub readonly: Cell<bool>,
    /// ESTree `static` property.
    pub r#static: Cell<bool>,
    /// ESTree `export` property.
    pub export: Cell<bool>,
}
impl<'gc> TSPropertySignature<'gc> {
    /// Build `TSPropertySignature` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        type_annotation: Option<&'gc Node<'gc>>,
        initializer: Option<&'gc Node<'gc>>,
        optional: bool,
        computed: bool,
        readonly: bool,
        r#static: bool,
        export: bool,
    ) -> Self {
        TSPropertySignature {
            metadata,
            key,
            type_annotation,
            initializer,
            optional: Cell::new(optional),
            computed: Cell::new(computed),
            readonly: Cell::new(readonly),
            r#static: Cell::new(r#static),
            export: Cell::new(export),
        }
    }
}

/// The `TSMethodSignature` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSMethodSignature<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `key` property.
    pub key: &'gc Node<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `returnType` property.
    pub return_type: Option<&'gc Node<'gc>>,
    /// ESTree `computed` property.
    pub computed: Cell<bool>,
}
impl<'gc> TSMethodSignature<'gc> {
    /// Build `TSMethodSignature` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        key: &'gc Node<'gc>,
        params: NodeList<'gc>,
        return_type: Option<&'gc Node<'gc>>,
        computed: bool,
    ) -> Self {
        TSMethodSignature {
            metadata,
            key,
            params,
            return_type,
            computed: Cell::new(computed),
        }
    }
}

/// The `TSIndexSignature` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSIndexSignature<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `parameters` property.
    pub parameters: NodeList<'gc>,
    /// ESTree `typeAnnotation` property.
    pub type_annotation: Option<&'gc Node<'gc>>,
}
impl<'gc> TSIndexSignature<'gc> {
    /// Build `TSIndexSignature` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        parameters: NodeList<'gc>,
        type_annotation: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSIndexSignature {
            metadata,
            parameters,
            type_annotation,
        }
    }
}

/// The `TSCallSignatureDeclaration` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSCallSignatureDeclaration<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `params` property.
    pub params: NodeList<'gc>,
    /// ESTree `returnType` property.
    pub return_type: Option<&'gc Node<'gc>>,
}
impl<'gc> TSCallSignatureDeclaration<'gc> {
    /// Build `TSCallSignatureDeclaration` from its metadata and `ESTree.def`
    /// fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        params: NodeList<'gc>,
        return_type: Option<&'gc Node<'gc>>,
    ) -> Self {
        TSCallSignatureDeclaration {
            metadata,
            params,
            return_type,
        }
    }
}

/// The `TSModifiers` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct TSModifiers<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `accessibility` property.
    pub accessibility: Cell<NodeLabel>,
    /// ESTree `readonly` property.
    pub readonly: Cell<bool>,
}
impl<'gc> TSModifiers<'gc> {
    /// Build `TSModifiers` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        accessibility: NodeLabel,
        readonly: bool,
    ) -> Self {
        TSModifiers {
            metadata,
            accessibility: Cell::new(accessibility),
            readonly: Cell::new(readonly),
        }
    }
    /// The `accessibility` label as UTF-8 text.
    ///
    /// Label fields hold identifier names, operators, keyword-like kinds and
    /// raw source spans. An identifier cannot contain an unpaired surrogate —
    /// the lexer rejects one with a dedicated diagnostic — and the remaining
    /// labels are literal source text, so in practice the bytes are already
    /// valid UTF-8 and this borrows them directly, allocating nothing.
    ///
    /// A label that is nevertheless unrepresentable, which realistically means
    /// a hand-built AST rather than a parsed one, has each unpaired surrogate
    /// rendered as a single U+FFFD instead of being reported. Only an unpaired
    /// surrogate is affected: a WTF-8 surrogate *pair* is folded back into the
    /// character it encodes, so a `"😀"` label comes out intact.
    ///
    /// Use [`GCLock::bytes`](crate::context::GCLock::bytes) for the exact
    /// bytes, or
    /// [`GCLock::try_bytes_str`](crate::context::GCLock::try_bytes_str) to
    /// detect the substitution. The returned `&str` borrows from `gc`, not from
    /// `self`.
    pub fn accessibility_str<'a>(
        &self,
        gc: &'a crate::context::GCLock<'_, '_>,
    ) -> &'a str {
        gc.bytes_str_lossy(self.accessibility.get())
    }
}

/// The `CoverEmptyArgs` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct CoverEmptyArgs<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> CoverEmptyArgs<'gc> {
    /// Build `CoverEmptyArgs` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        CoverEmptyArgs {
            metadata,
        }
    }
}

/// The `CoverTrailingComma` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct CoverTrailingComma<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> CoverTrailingComma<'gc> {
    /// Build `CoverTrailingComma` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        CoverTrailingComma {
            metadata,
        }
    }
}

/// The `CoverInitializer` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct CoverInitializer<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `init` property.
    pub init: &'gc Node<'gc>,
}
impl<'gc> CoverInitializer<'gc> {
    /// Build `CoverInitializer` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        init: &'gc Node<'gc>,
    ) -> Self {
        CoverInitializer {
            metadata,
            init,
        }
    }
}

/// The `CoverRestElement` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct CoverRestElement<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `rest` property.
    pub rest: &'gc Node<'gc>,
}
impl<'gc> CoverRestElement<'gc> {
    /// Build `CoverRestElement` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        rest: &'gc Node<'gc>,
    ) -> Self {
        CoverRestElement {
            metadata,
            rest,
        }
    }
}

/// The `CoverTypedIdentifier` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct CoverTypedIdentifier<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `left` property.
    pub left: &'gc Node<'gc>,
    /// ESTree `right` property.
    pub right: Option<&'gc Node<'gc>>,
    /// ESTree `optional` property.
    pub optional: Cell<bool>,
}
impl<'gc> CoverTypedIdentifier<'gc> {
    /// Build `CoverTypedIdentifier` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        left: &'gc Node<'gc>,
        right: Option<&'gc Node<'gc>>,
        optional: bool,
    ) -> Self {
        CoverTypedIdentifier {
            metadata,
            left,
            right,
            optional: Cell::new(optional),
        }
    }
}

/// The `SHBuiltin` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct SHBuiltin<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
}
impl<'gc> SHBuiltin<'gc> {
    /// Build `SHBuiltin` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
    ) -> Self {
        SHBuiltin {
            metadata,
        }
    }
}

/// The `ImplicitCheckedCast` AST node.
#[derive(Debug)]
#[repr(C)]
pub struct ImplicitCheckedCast<'gc> {
    /// Source range, debug location, paren count, and node id.
    pub metadata: NodeMetadata<'gc>,
    /// ESTree `argument` property.
    pub argument: &'gc Node<'gc>,
}
impl<'gc> ImplicitCheckedCast<'gc> {
    /// Build `ImplicitCheckedCast` from its metadata and `ESTree.def` fields.
    pub fn new(
        metadata: NodeMetadata<'gc>,
        argument: &'gc Node<'gc>,
    ) -> Self {
        ImplicitCheckedCast {
            metadata,
            argument,
        }
    }
}

/// An AST node: one arm per `ESTree.def` node kind.
///
/// `#[repr(C)]`, and each arm's payload struct is named after the arm,
/// so a deep `match` compiles to a single dispatch. Nodes live in the
/// [`crate::context::Context`] arena and are handed out as `&'gc Node`
/// for as long as a [`crate::context::GCLock`] is held.
#[derive(Debug)]
#[repr(C)]
pub enum Node<'gc> {
    /// A [`Empty`] node.
    Empty(Empty<'gc>),
    /// A [`Metadata`] node.
    Metadata(Metadata<'gc>),
    /// A [`Program`] node.
    Program(Program<'gc>),
    /// A [`FunctionExpression`] node.
    FunctionExpression(FunctionExpression<'gc>),
    /// A [`ArrowFunctionExpression`] node.
    ArrowFunctionExpression(ArrowFunctionExpression<'gc>),
    /// A [`FunctionDeclaration`] node.
    FunctionDeclaration(FunctionDeclaration<'gc>),
    /// A [`ComponentDeclaration`] node.
    ComponentDeclaration(ComponentDeclaration<'gc>),
    /// A [`HookDeclaration`] node.
    HookDeclaration(HookDeclaration<'gc>),
    /// A [`MatchStatement`] node.
    MatchStatement(MatchStatement<'gc>),
    /// A [`WhileStatement`] node.
    WhileStatement(WhileStatement<'gc>),
    /// A [`DoWhileStatement`] node.
    DoWhileStatement(DoWhileStatement<'gc>),
    /// A [`ForInStatement`] node.
    ForInStatement(ForInStatement<'gc>),
    /// A [`ForOfStatement`] node.
    ForOfStatement(ForOfStatement<'gc>),
    /// A [`ForStatement`] node.
    ForStatement(ForStatement<'gc>),
    /// A [`DebuggerStatement`] node.
    DebuggerStatement(DebuggerStatement<'gc>),
    /// A [`EmptyStatement`] node.
    EmptyStatement(EmptyStatement<'gc>),
    /// A [`BlockStatement`] node.
    BlockStatement(BlockStatement<'gc>),
    /// A [`StaticBlock`] node.
    StaticBlock(StaticBlock<'gc>),
    /// A [`BreakStatement`] node.
    BreakStatement(BreakStatement<'gc>),
    /// A [`ContinueStatement`] node.
    ContinueStatement(ContinueStatement<'gc>),
    /// A [`ThrowStatement`] node.
    ThrowStatement(ThrowStatement<'gc>),
    /// A [`ReturnStatement`] node.
    ReturnStatement(ReturnStatement<'gc>),
    /// A [`WithStatement`] node.
    WithStatement(WithStatement<'gc>),
    /// A [`SwitchStatement`] node.
    SwitchStatement(SwitchStatement<'gc>),
    /// A [`LabeledStatement`] node.
    LabeledStatement(LabeledStatement<'gc>),
    /// A [`ExpressionStatement`] node.
    ExpressionStatement(ExpressionStatement<'gc>),
    /// A [`TryStatement`] node.
    TryStatement(TryStatement<'gc>),
    /// A [`IfStatement`] node.
    IfStatement(IfStatement<'gc>),
    /// A [`NullLiteral`] node.
    NullLiteral(NullLiteral<'gc>),
    /// A [`BooleanLiteral`] node.
    BooleanLiteral(BooleanLiteral<'gc>),
    /// A [`StringLiteral`] node.
    StringLiteral(StringLiteral<'gc>),
    /// A [`NumericLiteral`] node.
    NumericLiteral(NumericLiteral<'gc>),
    /// A [`RegExpLiteral`] node.
    RegExpLiteral(RegExpLiteral<'gc>),
    /// A [`BigIntLiteral`] node.
    BigIntLiteral(BigIntLiteral<'gc>),
    /// A [`ThisExpression`] node.
    ThisExpression(ThisExpression<'gc>),
    /// A [`Super`] node.
    Super(Super<'gc>),
    /// A [`SequenceExpression`] node.
    SequenceExpression(SequenceExpression<'gc>),
    /// A [`ObjectExpression`] node.
    ObjectExpression(ObjectExpression<'gc>),
    /// A [`ArrayExpression`] node.
    ArrayExpression(ArrayExpression<'gc>),
    /// A [`SpreadElement`] node.
    SpreadElement(SpreadElement<'gc>),
    /// A [`NewExpression`] node.
    NewExpression(NewExpression<'gc>),
    /// A [`YieldExpression`] node.
    YieldExpression(YieldExpression<'gc>),
    /// A [`AwaitExpression`] node.
    AwaitExpression(AwaitExpression<'gc>),
    /// A [`ImportExpression`] node.
    ImportExpression(ImportExpression<'gc>),
    /// A [`CallExpression`] node.
    CallExpression(CallExpression<'gc>),
    /// A [`OptionalCallExpression`] node.
    OptionalCallExpression(OptionalCallExpression<'gc>),
    /// A [`AssignmentExpression`] node.
    AssignmentExpression(AssignmentExpression<'gc>),
    /// A [`UnaryExpression`] node.
    UnaryExpression(UnaryExpression<'gc>),
    /// A [`UpdateExpression`] node.
    UpdateExpression(UpdateExpression<'gc>),
    /// A [`MemberExpression`] node.
    MemberExpression(MemberExpression<'gc>),
    /// A [`OptionalMemberExpression`] node.
    OptionalMemberExpression(OptionalMemberExpression<'gc>),
    /// A [`LogicalExpression`] node.
    LogicalExpression(LogicalExpression<'gc>),
    /// A [`ConditionalExpression`] node.
    ConditionalExpression(ConditionalExpression<'gc>),
    /// A [`BinaryExpression`] node.
    BinaryExpression(BinaryExpression<'gc>),
    /// A [`Directive`] node.
    Directive(Directive<'gc>),
    /// A [`DirectiveLiteral`] node.
    DirectiveLiteral(DirectiveLiteral<'gc>),
    /// A [`Identifier`] node.
    Identifier(Identifier<'gc>),
    /// A [`PrivateName`] node.
    PrivateName(PrivateName<'gc>),
    /// A [`MetaProperty`] node.
    MetaProperty(MetaProperty<'gc>),
    /// A [`SwitchCase`] node.
    SwitchCase(SwitchCase<'gc>),
    /// A [`CatchClause`] node.
    CatchClause(CatchClause<'gc>),
    /// A [`VariableDeclarator`] node.
    VariableDeclarator(VariableDeclarator<'gc>),
    /// A [`VariableDeclaration`] node.
    VariableDeclaration(VariableDeclaration<'gc>),
    /// A [`TemplateLiteral`] node.
    TemplateLiteral(TemplateLiteral<'gc>),
    /// A [`TaggedTemplateExpression`] node.
    TaggedTemplateExpression(TaggedTemplateExpression<'gc>),
    /// A [`TemplateElement`] node.
    TemplateElement(TemplateElement<'gc>),
    /// A [`Property`] node.
    Property(Property<'gc>),
    /// A [`Decorator`] node.
    Decorator(Decorator<'gc>),
    /// A [`ClassDeclaration`] node.
    ClassDeclaration(ClassDeclaration<'gc>),
    /// A [`ClassExpression`] node.
    ClassExpression(ClassExpression<'gc>),
    /// A [`ClassBody`] node.
    ClassBody(ClassBody<'gc>),
    /// A [`ClassProperty`] node.
    ClassProperty(ClassProperty<'gc>),
    /// A [`ClassPrivateProperty`] node.
    ClassPrivateProperty(ClassPrivateProperty<'gc>),
    /// A [`MethodDefinition`] node.
    MethodDefinition(MethodDefinition<'gc>),
    /// A [`ImportDeclaration`] node.
    ImportDeclaration(ImportDeclaration<'gc>),
    /// A [`ImportSpecifier`] node.
    ImportSpecifier(ImportSpecifier<'gc>),
    /// A [`ImportDefaultSpecifier`] node.
    ImportDefaultSpecifier(ImportDefaultSpecifier<'gc>),
    /// A [`ImportNamespaceSpecifier`] node.
    ImportNamespaceSpecifier(ImportNamespaceSpecifier<'gc>),
    /// A [`ImportAttribute`] node.
    ImportAttribute(ImportAttribute<'gc>),
    /// A [`ExportNamedDeclaration`] node.
    ExportNamedDeclaration(ExportNamedDeclaration<'gc>),
    /// A [`ExportSpecifier`] node.
    ExportSpecifier(ExportSpecifier<'gc>),
    /// A [`ExportNamespaceSpecifier`] node.
    ExportNamespaceSpecifier(ExportNamespaceSpecifier<'gc>),
    /// A [`ExportDefaultDeclaration`] node.
    ExportDefaultDeclaration(ExportDefaultDeclaration<'gc>),
    /// A [`ExportAllDeclaration`] node.
    ExportAllDeclaration(ExportAllDeclaration<'gc>),
    /// A [`ObjectPattern`] node.
    ObjectPattern(ObjectPattern<'gc>),
    /// A [`ArrayPattern`] node.
    ArrayPattern(ArrayPattern<'gc>),
    /// A [`RestElement`] node.
    RestElement(RestElement<'gc>),
    /// A [`AssignmentPattern`] node.
    AssignmentPattern(AssignmentPattern<'gc>),
    /// A [`MatchStatementCase`] node.
    MatchStatementCase(MatchStatementCase<'gc>),
    /// A [`MatchExpression`] node.
    MatchExpression(MatchExpression<'gc>),
    /// A [`MatchExpressionCase`] node.
    MatchExpressionCase(MatchExpressionCase<'gc>),
    /// A [`MatchWildcardPattern`] node.
    MatchWildcardPattern(MatchWildcardPattern<'gc>),
    /// A [`MatchLiteralPattern`] node.
    MatchLiteralPattern(MatchLiteralPattern<'gc>),
    /// A [`MatchUnaryPattern`] node.
    MatchUnaryPattern(MatchUnaryPattern<'gc>),
    /// A [`MatchIdentifierPattern`] node.
    MatchIdentifierPattern(MatchIdentifierPattern<'gc>),
    /// A [`MatchBindingPattern`] node.
    MatchBindingPattern(MatchBindingPattern<'gc>),
    /// A [`MatchObjectPattern`] node.
    MatchObjectPattern(MatchObjectPattern<'gc>),
    /// A [`MatchArrayPattern`] node.
    MatchArrayPattern(MatchArrayPattern<'gc>),
    /// A [`MatchOrPattern`] node.
    MatchOrPattern(MatchOrPattern<'gc>),
    /// A [`MatchAsPattern`] node.
    MatchAsPattern(MatchAsPattern<'gc>),
    /// A [`MatchMemberPattern`] node.
    MatchMemberPattern(MatchMemberPattern<'gc>),
    /// A [`MatchInstancePattern`] node.
    MatchInstancePattern(MatchInstancePattern<'gc>),
    /// A [`MatchObjectPatternProperty`] node.
    MatchObjectPatternProperty(MatchObjectPatternProperty<'gc>),
    /// A [`MatchInstanceObjectPattern`] node.
    MatchInstanceObjectPattern(MatchInstanceObjectPattern<'gc>),
    /// A [`MatchRestPattern`] node.
    MatchRestPattern(MatchRestPattern<'gc>),
    /// A [`JSXIdentifier`] node.
    JSXIdentifier(JSXIdentifier<'gc>),
    /// A [`JSXMemberExpression`] node.
    JSXMemberExpression(JSXMemberExpression<'gc>),
    /// A [`JSXNamespacedName`] node.
    JSXNamespacedName(JSXNamespacedName<'gc>),
    /// A [`JSXEmptyExpression`] node.
    JSXEmptyExpression(JSXEmptyExpression<'gc>),
    /// A [`JSXExpressionContainer`] node.
    JSXExpressionContainer(JSXExpressionContainer<'gc>),
    /// A [`JSXSpreadChild`] node.
    JSXSpreadChild(JSXSpreadChild<'gc>),
    /// A [`JSXOpeningElement`] node.
    JSXOpeningElement(JSXOpeningElement<'gc>),
    /// A [`JSXClosingElement`] node.
    JSXClosingElement(JSXClosingElement<'gc>),
    /// A [`JSXAttribute`] node.
    JSXAttribute(JSXAttribute<'gc>),
    /// A [`JSXSpreadAttribute`] node.
    JSXSpreadAttribute(JSXSpreadAttribute<'gc>),
    /// A [`JSXStringLiteral`] node.
    JSXStringLiteral(JSXStringLiteral<'gc>),
    /// A [`JSXText`] node.
    JSXText(JSXText<'gc>),
    /// A [`JSXElement`] node.
    JSXElement(JSXElement<'gc>),
    /// A [`JSXFragment`] node.
    JSXFragment(JSXFragment<'gc>),
    /// A [`JSXOpeningFragment`] node.
    JSXOpeningFragment(JSXOpeningFragment<'gc>),
    /// A [`JSXClosingFragment`] node.
    JSXClosingFragment(JSXClosingFragment<'gc>),
    /// A [`ExistsTypeAnnotation`] node.
    ExistsTypeAnnotation(ExistsTypeAnnotation<'gc>),
    /// A [`EmptyTypeAnnotation`] node.
    EmptyTypeAnnotation(EmptyTypeAnnotation<'gc>),
    /// A [`StringTypeAnnotation`] node.
    StringTypeAnnotation(StringTypeAnnotation<'gc>),
    /// A [`NumberTypeAnnotation`] node.
    NumberTypeAnnotation(NumberTypeAnnotation<'gc>),
    /// A [`StringLiteralTypeAnnotation`] node.
    StringLiteralTypeAnnotation(StringLiteralTypeAnnotation<'gc>),
    /// A [`NumberLiteralTypeAnnotation`] node.
    NumberLiteralTypeAnnotation(NumberLiteralTypeAnnotation<'gc>),
    /// A [`BigIntLiteralTypeAnnotation`] node.
    BigIntLiteralTypeAnnotation(BigIntLiteralTypeAnnotation<'gc>),
    /// A [`BooleanTypeAnnotation`] node.
    BooleanTypeAnnotation(BooleanTypeAnnotation<'gc>),
    /// A [`BooleanLiteralTypeAnnotation`] node.
    BooleanLiteralTypeAnnotation(BooleanLiteralTypeAnnotation<'gc>),
    /// A [`NullLiteralTypeAnnotation`] node.
    NullLiteralTypeAnnotation(NullLiteralTypeAnnotation<'gc>),
    /// A [`SymbolTypeAnnotation`] node.
    SymbolTypeAnnotation(SymbolTypeAnnotation<'gc>),
    /// A [`AnyTypeAnnotation`] node.
    AnyTypeAnnotation(AnyTypeAnnotation<'gc>),
    /// A [`MixedTypeAnnotation`] node.
    MixedTypeAnnotation(MixedTypeAnnotation<'gc>),
    /// A [`BigIntTypeAnnotation`] node.
    BigIntTypeAnnotation(BigIntTypeAnnotation<'gc>),
    /// A [`VoidTypeAnnotation`] node.
    VoidTypeAnnotation(VoidTypeAnnotation<'gc>),
    /// A [`NeverTypeAnnotation`] node.
    NeverTypeAnnotation(NeverTypeAnnotation<'gc>),
    /// A [`UnknownTypeAnnotation`] node.
    UnknownTypeAnnotation(UnknownTypeAnnotation<'gc>),
    /// A [`UndefinedTypeAnnotation`] node.
    UndefinedTypeAnnotation(UndefinedTypeAnnotation<'gc>),
    /// A [`FunctionTypeAnnotation`] node.
    FunctionTypeAnnotation(FunctionTypeAnnotation<'gc>),
    /// A [`HookTypeAnnotation`] node.
    HookTypeAnnotation(HookTypeAnnotation<'gc>),
    /// A [`FunctionTypeParam`] node.
    FunctionTypeParam(FunctionTypeParam<'gc>),
    /// A [`ComponentTypeAnnotation`] node.
    ComponentTypeAnnotation(ComponentTypeAnnotation<'gc>),
    /// A [`ComponentTypeParameter`] node.
    ComponentTypeParameter(ComponentTypeParameter<'gc>),
    /// A [`NullableTypeAnnotation`] node.
    NullableTypeAnnotation(NullableTypeAnnotation<'gc>),
    /// A [`QualifiedTypeIdentifier`] node.
    QualifiedTypeIdentifier(QualifiedTypeIdentifier<'gc>),
    /// A [`TypeofTypeAnnotation`] node.
    TypeofTypeAnnotation(TypeofTypeAnnotation<'gc>),
    /// A [`KeyofTypeAnnotation`] node.
    KeyofTypeAnnotation(KeyofTypeAnnotation<'gc>),
    /// A [`TypeOperator`] node.
    TypeOperator(TypeOperator<'gc>),
    /// A [`QualifiedTypeofIdentifier`] node.
    QualifiedTypeofIdentifier(QualifiedTypeofIdentifier<'gc>),
    /// A [`TupleTypeAnnotation`] node.
    TupleTypeAnnotation(TupleTypeAnnotation<'gc>),
    /// A [`TupleTypeSpreadElement`] node.
    TupleTypeSpreadElement(TupleTypeSpreadElement<'gc>),
    /// A [`TupleTypeLabeledElement`] node.
    TupleTypeLabeledElement(TupleTypeLabeledElement<'gc>),
    /// A [`ArrayTypeAnnotation`] node.
    ArrayTypeAnnotation(ArrayTypeAnnotation<'gc>),
    /// A [`InferTypeAnnotation`] node.
    InferTypeAnnotation(InferTypeAnnotation<'gc>),
    /// A [`UnionTypeAnnotation`] node.
    UnionTypeAnnotation(UnionTypeAnnotation<'gc>),
    /// A [`IntersectionTypeAnnotation`] node.
    IntersectionTypeAnnotation(IntersectionTypeAnnotation<'gc>),
    /// A [`GenericTypeAnnotation`] node.
    GenericTypeAnnotation(GenericTypeAnnotation<'gc>),
    /// A [`IndexedAccessType`] node.
    IndexedAccessType(IndexedAccessType<'gc>),
    /// A [`OptionalIndexedAccessType`] node.
    OptionalIndexedAccessType(OptionalIndexedAccessType<'gc>),
    /// A [`ConditionalTypeAnnotation`] node.
    ConditionalTypeAnnotation(ConditionalTypeAnnotation<'gc>),
    /// A [`TypePredicate`] node.
    TypePredicate(TypePredicate<'gc>),
    /// A [`InterfaceTypeAnnotation`] node.
    InterfaceTypeAnnotation(InterfaceTypeAnnotation<'gc>),
    /// A [`TypeAlias`] node.
    TypeAlias(TypeAlias<'gc>),
    /// A [`OpaqueType`] node.
    OpaqueType(OpaqueType<'gc>),
    /// A [`InterfaceDeclaration`] node.
    InterfaceDeclaration(InterfaceDeclaration<'gc>),
    /// A [`DeclareTypeAlias`] node.
    DeclareTypeAlias(DeclareTypeAlias<'gc>),
    /// A [`DeclareOpaqueType`] node.
    DeclareOpaqueType(DeclareOpaqueType<'gc>),
    /// A [`DeclareInterface`] node.
    DeclareInterface(DeclareInterface<'gc>),
    /// A [`DeclareClass`] node.
    DeclareClass(DeclareClass<'gc>),
    /// A [`DeclareFunction`] node.
    DeclareFunction(DeclareFunction<'gc>),
    /// A [`DeclareHook`] node.
    DeclareHook(DeclareHook<'gc>),
    /// A [`DeclareComponent`] node.
    DeclareComponent(DeclareComponent<'gc>),
    /// A [`DeclareVariable`] node.
    DeclareVariable(DeclareVariable<'gc>),
    /// A [`DeclareEnum`] node.
    DeclareEnum(DeclareEnum<'gc>),
    /// A [`DeclareExportDeclaration`] node.
    DeclareExportDeclaration(DeclareExportDeclaration<'gc>),
    /// A [`DeclareExportAllDeclaration`] node.
    DeclareExportAllDeclaration(DeclareExportAllDeclaration<'gc>),
    /// A [`DeclareModule`] node.
    DeclareModule(DeclareModule<'gc>),
    /// A [`DeclareNamespace`] node.
    DeclareNamespace(DeclareNamespace<'gc>),
    /// A [`DeclareModuleExports`] node.
    DeclareModuleExports(DeclareModuleExports<'gc>),
    /// A [`InterfaceExtends`] node.
    InterfaceExtends(InterfaceExtends<'gc>),
    /// A [`ClassImplements`] node.
    ClassImplements(ClassImplements<'gc>),
    /// A [`TypeAnnotation`] node.
    TypeAnnotation(TypeAnnotation<'gc>),
    /// A [`ObjectTypeAnnotation`] node.
    ObjectTypeAnnotation(ObjectTypeAnnotation<'gc>),
    /// A [`ObjectTypeProperty`] node.
    ObjectTypeProperty(ObjectTypeProperty<'gc>),
    /// A [`ObjectTypeSpreadProperty`] node.
    ObjectTypeSpreadProperty(ObjectTypeSpreadProperty<'gc>),
    /// A [`ObjectTypeInternalSlot`] node.
    ObjectTypeInternalSlot(ObjectTypeInternalSlot<'gc>),
    /// A [`ObjectTypeCallProperty`] node.
    ObjectTypeCallProperty(ObjectTypeCallProperty<'gc>),
    /// A [`ObjectTypeIndexer`] node.
    ObjectTypeIndexer(ObjectTypeIndexer<'gc>),
    /// A [`ObjectTypeMappedTypeProperty`] node.
    ObjectTypeMappedTypeProperty(ObjectTypeMappedTypeProperty<'gc>),
    /// A [`Variance`] node.
    Variance(Variance<'gc>),
    /// A [`TypeParameterDeclaration`] node.
    TypeParameterDeclaration(TypeParameterDeclaration<'gc>),
    /// A [`TypeParameter`] node.
    TypeParameter(TypeParameter<'gc>),
    /// A [`TypeParameterInstantiation`] node.
    TypeParameterInstantiation(TypeParameterInstantiation<'gc>),
    /// A [`TypeCastExpression`] node.
    TypeCastExpression(TypeCastExpression<'gc>),
    /// A [`AsExpression`] node.
    AsExpression(AsExpression<'gc>),
    /// A [`AsConstExpression`] node.
    AsConstExpression(AsConstExpression<'gc>),
    /// A [`InferredPredicate`] node.
    InferredPredicate(InferredPredicate<'gc>),
    /// A [`DeclaredPredicate`] node.
    DeclaredPredicate(DeclaredPredicate<'gc>),
    /// A [`EnumDeclaration`] node.
    EnumDeclaration(EnumDeclaration<'gc>),
    /// A [`EnumStringBody`] node.
    EnumStringBody(EnumStringBody<'gc>),
    /// A [`EnumNumberBody`] node.
    EnumNumberBody(EnumNumberBody<'gc>),
    /// A [`EnumBigIntBody`] node.
    EnumBigIntBody(EnumBigIntBody<'gc>),
    /// A [`EnumBooleanBody`] node.
    EnumBooleanBody(EnumBooleanBody<'gc>),
    /// A [`EnumSymbolBody`] node.
    EnumSymbolBody(EnumSymbolBody<'gc>),
    /// A [`EnumDefaultedMember`] node.
    EnumDefaultedMember(EnumDefaultedMember<'gc>),
    /// A [`EnumStringMember`] node.
    EnumStringMember(EnumStringMember<'gc>),
    /// A [`EnumNumberMember`] node.
    EnumNumberMember(EnumNumberMember<'gc>),
    /// A [`EnumBigIntMember`] node.
    EnumBigIntMember(EnumBigIntMember<'gc>),
    /// A [`EnumBooleanMember`] node.
    EnumBooleanMember(EnumBooleanMember<'gc>),
    /// A [`ComponentParameter`] node.
    ComponentParameter(ComponentParameter<'gc>),
    /// A [`RecordDeclaration`] node.
    RecordDeclaration(RecordDeclaration<'gc>),
    /// A [`RecordDeclarationImplements`] node.
    RecordDeclarationImplements(RecordDeclarationImplements<'gc>),
    /// A [`RecordDeclarationBody`] node.
    RecordDeclarationBody(RecordDeclarationBody<'gc>),
    /// A [`RecordDeclarationProperty`] node.
    RecordDeclarationProperty(RecordDeclarationProperty<'gc>),
    /// A [`RecordDeclarationStaticProperty`] node.
    RecordDeclarationStaticProperty(RecordDeclarationStaticProperty<'gc>),
    /// A [`RecordExpression`] node.
    RecordExpression(RecordExpression<'gc>),
    /// A [`RecordExpressionProperties`] node.
    RecordExpressionProperties(RecordExpressionProperties<'gc>),
    /// A [`TSTypeAnnotation`] node.
    TSTypeAnnotation(TSTypeAnnotation<'gc>),
    /// A [`TSAnyKeyword`] node.
    TSAnyKeyword(TSAnyKeyword<'gc>),
    /// A [`TSNumberKeyword`] node.
    TSNumberKeyword(TSNumberKeyword<'gc>),
    /// A [`TSBooleanKeyword`] node.
    TSBooleanKeyword(TSBooleanKeyword<'gc>),
    /// A [`TSStringKeyword`] node.
    TSStringKeyword(TSStringKeyword<'gc>),
    /// A [`TSSymbolKeyword`] node.
    TSSymbolKeyword(TSSymbolKeyword<'gc>),
    /// A [`TSVoidKeyword`] node.
    TSVoidKeyword(TSVoidKeyword<'gc>),
    /// A [`TSUndefinedKeyword`] node.
    TSUndefinedKeyword(TSUndefinedKeyword<'gc>),
    /// A [`TSUnknownKeyword`] node.
    TSUnknownKeyword(TSUnknownKeyword<'gc>),
    /// A [`TSNeverKeyword`] node.
    TSNeverKeyword(TSNeverKeyword<'gc>),
    /// A [`TSBigIntKeyword`] node.
    TSBigIntKeyword(TSBigIntKeyword<'gc>),
    /// A [`TSThisType`] node.
    TSThisType(TSThisType<'gc>),
    /// A [`TSLiteralType`] node.
    TSLiteralType(TSLiteralType<'gc>),
    /// A [`TSIndexedAccessType`] node.
    TSIndexedAccessType(TSIndexedAccessType<'gc>),
    /// A [`TSArrayType`] node.
    TSArrayType(TSArrayType<'gc>),
    /// A [`TSTypeReference`] node.
    TSTypeReference(TSTypeReference<'gc>),
    /// A [`TSQualifiedName`] node.
    TSQualifiedName(TSQualifiedName<'gc>),
    /// A [`TSFunctionType`] node.
    TSFunctionType(TSFunctionType<'gc>),
    /// A [`TSConstructorType`] node.
    TSConstructorType(TSConstructorType<'gc>),
    /// A [`TSTypePredicate`] node.
    TSTypePredicate(TSTypePredicate<'gc>),
    /// A [`TSTupleType`] node.
    TSTupleType(TSTupleType<'gc>),
    /// A [`TSTypeAssertion`] node.
    TSTypeAssertion(TSTypeAssertion<'gc>),
    /// A [`TSAsExpression`] node.
    TSAsExpression(TSAsExpression<'gc>),
    /// A [`TSParameterProperty`] node.
    TSParameterProperty(TSParameterProperty<'gc>),
    /// A [`TSTypeAliasDeclaration`] node.
    TSTypeAliasDeclaration(TSTypeAliasDeclaration<'gc>),
    /// A [`TSInterfaceDeclaration`] node.
    TSInterfaceDeclaration(TSInterfaceDeclaration<'gc>),
    /// A [`TSInterfaceHeritage`] node.
    TSInterfaceHeritage(TSInterfaceHeritage<'gc>),
    /// A [`TSInterfaceBody`] node.
    TSInterfaceBody(TSInterfaceBody<'gc>),
    /// A [`TSEnumDeclaration`] node.
    TSEnumDeclaration(TSEnumDeclaration<'gc>),
    /// A [`TSEnumMember`] node.
    TSEnumMember(TSEnumMember<'gc>),
    /// A [`TSModuleDeclaration`] node.
    TSModuleDeclaration(TSModuleDeclaration<'gc>),
    /// A [`TSModuleBlock`] node.
    TSModuleBlock(TSModuleBlock<'gc>),
    /// A [`TSModuleMember`] node.
    TSModuleMember(TSModuleMember<'gc>),
    /// A [`TSTypeParameterDeclaration`] node.
    TSTypeParameterDeclaration(TSTypeParameterDeclaration<'gc>),
    /// A [`TSTypeParameter`] node.
    TSTypeParameter(TSTypeParameter<'gc>),
    /// A [`TSTypeParameterInstantiation`] node.
    TSTypeParameterInstantiation(TSTypeParameterInstantiation<'gc>),
    /// A [`TSUnionType`] node.
    TSUnionType(TSUnionType<'gc>),
    /// A [`TSIntersectionType`] node.
    TSIntersectionType(TSIntersectionType<'gc>),
    /// A [`TSTypeQuery`] node.
    TSTypeQuery(TSTypeQuery<'gc>),
    /// A [`TSConditionalType`] node.
    TSConditionalType(TSConditionalType<'gc>),
    /// A [`TSTypeLiteral`] node.
    TSTypeLiteral(TSTypeLiteral<'gc>),
    /// A [`TSPropertySignature`] node.
    TSPropertySignature(TSPropertySignature<'gc>),
    /// A [`TSMethodSignature`] node.
    TSMethodSignature(TSMethodSignature<'gc>),
    /// A [`TSIndexSignature`] node.
    TSIndexSignature(TSIndexSignature<'gc>),
    /// A [`TSCallSignatureDeclaration`] node.
    TSCallSignatureDeclaration(TSCallSignatureDeclaration<'gc>),
    /// A [`TSModifiers`] node.
    TSModifiers(TSModifiers<'gc>),
    /// A [`CoverEmptyArgs`] node.
    CoverEmptyArgs(CoverEmptyArgs<'gc>),
    /// A [`CoverTrailingComma`] node.
    CoverTrailingComma(CoverTrailingComma<'gc>),
    /// A [`CoverInitializer`] node.
    CoverInitializer(CoverInitializer<'gc>),
    /// A [`CoverRestElement`] node.
    CoverRestElement(CoverRestElement<'gc>),
    /// A [`CoverTypedIdentifier`] node.
    CoverTypedIdentifier(CoverTypedIdentifier<'gc>),
    /// A [`SHBuiltin`] node.
    SHBuiltin(SHBuiltin<'gc>),
    /// A [`ImplicitCheckedCast`] node.
    ImplicitCheckedCast(ImplicitCheckedCast<'gc>),
}

impl<'gc> Node<'gc> {
    /// This node's [`NodeKind`].
    pub fn kind(&self) -> NodeKind {
        match self {
            Node::Empty(_) => NodeKind::Empty,
            Node::Metadata(_) => NodeKind::Metadata,
            Node::Program(_) => NodeKind::Program,
            Node::FunctionExpression(_) => NodeKind::FunctionExpression,
            Node::ArrowFunctionExpression(_) => NodeKind::ArrowFunctionExpression,
            Node::FunctionDeclaration(_) => NodeKind::FunctionDeclaration,
            Node::ComponentDeclaration(_) => NodeKind::ComponentDeclaration,
            Node::HookDeclaration(_) => NodeKind::HookDeclaration,
            Node::MatchStatement(_) => NodeKind::MatchStatement,
            Node::WhileStatement(_) => NodeKind::WhileStatement,
            Node::DoWhileStatement(_) => NodeKind::DoWhileStatement,
            Node::ForInStatement(_) => NodeKind::ForInStatement,
            Node::ForOfStatement(_) => NodeKind::ForOfStatement,
            Node::ForStatement(_) => NodeKind::ForStatement,
            Node::DebuggerStatement(_) => NodeKind::DebuggerStatement,
            Node::EmptyStatement(_) => NodeKind::EmptyStatement,
            Node::BlockStatement(_) => NodeKind::BlockStatement,
            Node::StaticBlock(_) => NodeKind::StaticBlock,
            Node::BreakStatement(_) => NodeKind::BreakStatement,
            Node::ContinueStatement(_) => NodeKind::ContinueStatement,
            Node::ThrowStatement(_) => NodeKind::ThrowStatement,
            Node::ReturnStatement(_) => NodeKind::ReturnStatement,
            Node::WithStatement(_) => NodeKind::WithStatement,
            Node::SwitchStatement(_) => NodeKind::SwitchStatement,
            Node::LabeledStatement(_) => NodeKind::LabeledStatement,
            Node::ExpressionStatement(_) => NodeKind::ExpressionStatement,
            Node::TryStatement(_) => NodeKind::TryStatement,
            Node::IfStatement(_) => NodeKind::IfStatement,
            Node::NullLiteral(_) => NodeKind::NullLiteral,
            Node::BooleanLiteral(_) => NodeKind::BooleanLiteral,
            Node::StringLiteral(_) => NodeKind::StringLiteral,
            Node::NumericLiteral(_) => NodeKind::NumericLiteral,
            Node::RegExpLiteral(_) => NodeKind::RegExpLiteral,
            Node::BigIntLiteral(_) => NodeKind::BigIntLiteral,
            Node::ThisExpression(_) => NodeKind::ThisExpression,
            Node::Super(_) => NodeKind::Super,
            Node::SequenceExpression(_) => NodeKind::SequenceExpression,
            Node::ObjectExpression(_) => NodeKind::ObjectExpression,
            Node::ArrayExpression(_) => NodeKind::ArrayExpression,
            Node::SpreadElement(_) => NodeKind::SpreadElement,
            Node::NewExpression(_) => NodeKind::NewExpression,
            Node::YieldExpression(_) => NodeKind::YieldExpression,
            Node::AwaitExpression(_) => NodeKind::AwaitExpression,
            Node::ImportExpression(_) => NodeKind::ImportExpression,
            Node::CallExpression(_) => NodeKind::CallExpression,
            Node::OptionalCallExpression(_) => NodeKind::OptionalCallExpression,
            Node::AssignmentExpression(_) => NodeKind::AssignmentExpression,
            Node::UnaryExpression(_) => NodeKind::UnaryExpression,
            Node::UpdateExpression(_) => NodeKind::UpdateExpression,
            Node::MemberExpression(_) => NodeKind::MemberExpression,
            Node::OptionalMemberExpression(_) => NodeKind::OptionalMemberExpression,
            Node::LogicalExpression(_) => NodeKind::LogicalExpression,
            Node::ConditionalExpression(_) => NodeKind::ConditionalExpression,
            Node::BinaryExpression(_) => NodeKind::BinaryExpression,
            Node::Directive(_) => NodeKind::Directive,
            Node::DirectiveLiteral(_) => NodeKind::DirectiveLiteral,
            Node::Identifier(_) => NodeKind::Identifier,
            Node::PrivateName(_) => NodeKind::PrivateName,
            Node::MetaProperty(_) => NodeKind::MetaProperty,
            Node::SwitchCase(_) => NodeKind::SwitchCase,
            Node::CatchClause(_) => NodeKind::CatchClause,
            Node::VariableDeclarator(_) => NodeKind::VariableDeclarator,
            Node::VariableDeclaration(_) => NodeKind::VariableDeclaration,
            Node::TemplateLiteral(_) => NodeKind::TemplateLiteral,
            Node::TaggedTemplateExpression(_) => NodeKind::TaggedTemplateExpression,
            Node::TemplateElement(_) => NodeKind::TemplateElement,
            Node::Property(_) => NodeKind::Property,
            Node::Decorator(_) => NodeKind::Decorator,
            Node::ClassDeclaration(_) => NodeKind::ClassDeclaration,
            Node::ClassExpression(_) => NodeKind::ClassExpression,
            Node::ClassBody(_) => NodeKind::ClassBody,
            Node::ClassProperty(_) => NodeKind::ClassProperty,
            Node::ClassPrivateProperty(_) => NodeKind::ClassPrivateProperty,
            Node::MethodDefinition(_) => NodeKind::MethodDefinition,
            Node::ImportDeclaration(_) => NodeKind::ImportDeclaration,
            Node::ImportSpecifier(_) => NodeKind::ImportSpecifier,
            Node::ImportDefaultSpecifier(_) => NodeKind::ImportDefaultSpecifier,
            Node::ImportNamespaceSpecifier(_) => NodeKind::ImportNamespaceSpecifier,
            Node::ImportAttribute(_) => NodeKind::ImportAttribute,
            Node::ExportNamedDeclaration(_) => NodeKind::ExportNamedDeclaration,
            Node::ExportSpecifier(_) => NodeKind::ExportSpecifier,
            Node::ExportNamespaceSpecifier(_) => NodeKind::ExportNamespaceSpecifier,
            Node::ExportDefaultDeclaration(_) => NodeKind::ExportDefaultDeclaration,
            Node::ExportAllDeclaration(_) => NodeKind::ExportAllDeclaration,
            Node::ObjectPattern(_) => NodeKind::ObjectPattern,
            Node::ArrayPattern(_) => NodeKind::ArrayPattern,
            Node::RestElement(_) => NodeKind::RestElement,
            Node::AssignmentPattern(_) => NodeKind::AssignmentPattern,
            Node::MatchStatementCase(_) => NodeKind::MatchStatementCase,
            Node::MatchExpression(_) => NodeKind::MatchExpression,
            Node::MatchExpressionCase(_) => NodeKind::MatchExpressionCase,
            Node::MatchWildcardPattern(_) => NodeKind::MatchWildcardPattern,
            Node::MatchLiteralPattern(_) => NodeKind::MatchLiteralPattern,
            Node::MatchUnaryPattern(_) => NodeKind::MatchUnaryPattern,
            Node::MatchIdentifierPattern(_) => NodeKind::MatchIdentifierPattern,
            Node::MatchBindingPattern(_) => NodeKind::MatchBindingPattern,
            Node::MatchObjectPattern(_) => NodeKind::MatchObjectPattern,
            Node::MatchArrayPattern(_) => NodeKind::MatchArrayPattern,
            Node::MatchOrPattern(_) => NodeKind::MatchOrPattern,
            Node::MatchAsPattern(_) => NodeKind::MatchAsPattern,
            Node::MatchMemberPattern(_) => NodeKind::MatchMemberPattern,
            Node::MatchInstancePattern(_) => NodeKind::MatchInstancePattern,
            Node::MatchObjectPatternProperty(_) => NodeKind::MatchObjectPatternProperty,
            Node::MatchInstanceObjectPattern(_) => NodeKind::MatchInstanceObjectPattern,
            Node::MatchRestPattern(_) => NodeKind::MatchRestPattern,
            Node::JSXIdentifier(_) => NodeKind::JSXIdentifier,
            Node::JSXMemberExpression(_) => NodeKind::JSXMemberExpression,
            Node::JSXNamespacedName(_) => NodeKind::JSXNamespacedName,
            Node::JSXEmptyExpression(_) => NodeKind::JSXEmptyExpression,
            Node::JSXExpressionContainer(_) => NodeKind::JSXExpressionContainer,
            Node::JSXSpreadChild(_) => NodeKind::JSXSpreadChild,
            Node::JSXOpeningElement(_) => NodeKind::JSXOpeningElement,
            Node::JSXClosingElement(_) => NodeKind::JSXClosingElement,
            Node::JSXAttribute(_) => NodeKind::JSXAttribute,
            Node::JSXSpreadAttribute(_) => NodeKind::JSXSpreadAttribute,
            Node::JSXStringLiteral(_) => NodeKind::JSXStringLiteral,
            Node::JSXText(_) => NodeKind::JSXText,
            Node::JSXElement(_) => NodeKind::JSXElement,
            Node::JSXFragment(_) => NodeKind::JSXFragment,
            Node::JSXOpeningFragment(_) => NodeKind::JSXOpeningFragment,
            Node::JSXClosingFragment(_) => NodeKind::JSXClosingFragment,
            Node::ExistsTypeAnnotation(_) => NodeKind::ExistsTypeAnnotation,
            Node::EmptyTypeAnnotation(_) => NodeKind::EmptyTypeAnnotation,
            Node::StringTypeAnnotation(_) => NodeKind::StringTypeAnnotation,
            Node::NumberTypeAnnotation(_) => NodeKind::NumberTypeAnnotation,
            Node::StringLiteralTypeAnnotation(_) => NodeKind::StringLiteralTypeAnnotation,
            Node::NumberLiteralTypeAnnotation(_) => NodeKind::NumberLiteralTypeAnnotation,
            Node::BigIntLiteralTypeAnnotation(_) => NodeKind::BigIntLiteralTypeAnnotation,
            Node::BooleanTypeAnnotation(_) => NodeKind::BooleanTypeAnnotation,
            Node::BooleanLiteralTypeAnnotation(_) => NodeKind::BooleanLiteralTypeAnnotation,
            Node::NullLiteralTypeAnnotation(_) => NodeKind::NullLiteralTypeAnnotation,
            Node::SymbolTypeAnnotation(_) => NodeKind::SymbolTypeAnnotation,
            Node::AnyTypeAnnotation(_) => NodeKind::AnyTypeAnnotation,
            Node::MixedTypeAnnotation(_) => NodeKind::MixedTypeAnnotation,
            Node::BigIntTypeAnnotation(_) => NodeKind::BigIntTypeAnnotation,
            Node::VoidTypeAnnotation(_) => NodeKind::VoidTypeAnnotation,
            Node::NeverTypeAnnotation(_) => NodeKind::NeverTypeAnnotation,
            Node::UnknownTypeAnnotation(_) => NodeKind::UnknownTypeAnnotation,
            Node::UndefinedTypeAnnotation(_) => NodeKind::UndefinedTypeAnnotation,
            Node::FunctionTypeAnnotation(_) => NodeKind::FunctionTypeAnnotation,
            Node::HookTypeAnnotation(_) => NodeKind::HookTypeAnnotation,
            Node::FunctionTypeParam(_) => NodeKind::FunctionTypeParam,
            Node::ComponentTypeAnnotation(_) => NodeKind::ComponentTypeAnnotation,
            Node::ComponentTypeParameter(_) => NodeKind::ComponentTypeParameter,
            Node::NullableTypeAnnotation(_) => NodeKind::NullableTypeAnnotation,
            Node::QualifiedTypeIdentifier(_) => NodeKind::QualifiedTypeIdentifier,
            Node::TypeofTypeAnnotation(_) => NodeKind::TypeofTypeAnnotation,
            Node::KeyofTypeAnnotation(_) => NodeKind::KeyofTypeAnnotation,
            Node::TypeOperator(_) => NodeKind::TypeOperator,
            Node::QualifiedTypeofIdentifier(_) => NodeKind::QualifiedTypeofIdentifier,
            Node::TupleTypeAnnotation(_) => NodeKind::TupleTypeAnnotation,
            Node::TupleTypeSpreadElement(_) => NodeKind::TupleTypeSpreadElement,
            Node::TupleTypeLabeledElement(_) => NodeKind::TupleTypeLabeledElement,
            Node::ArrayTypeAnnotation(_) => NodeKind::ArrayTypeAnnotation,
            Node::InferTypeAnnotation(_) => NodeKind::InferTypeAnnotation,
            Node::UnionTypeAnnotation(_) => NodeKind::UnionTypeAnnotation,
            Node::IntersectionTypeAnnotation(_) => NodeKind::IntersectionTypeAnnotation,
            Node::GenericTypeAnnotation(_) => NodeKind::GenericTypeAnnotation,
            Node::IndexedAccessType(_) => NodeKind::IndexedAccessType,
            Node::OptionalIndexedAccessType(_) => NodeKind::OptionalIndexedAccessType,
            Node::ConditionalTypeAnnotation(_) => NodeKind::ConditionalTypeAnnotation,
            Node::TypePredicate(_) => NodeKind::TypePredicate,
            Node::InterfaceTypeAnnotation(_) => NodeKind::InterfaceTypeAnnotation,
            Node::TypeAlias(_) => NodeKind::TypeAlias,
            Node::OpaqueType(_) => NodeKind::OpaqueType,
            Node::InterfaceDeclaration(_) => NodeKind::InterfaceDeclaration,
            Node::DeclareTypeAlias(_) => NodeKind::DeclareTypeAlias,
            Node::DeclareOpaqueType(_) => NodeKind::DeclareOpaqueType,
            Node::DeclareInterface(_) => NodeKind::DeclareInterface,
            Node::DeclareClass(_) => NodeKind::DeclareClass,
            Node::DeclareFunction(_) => NodeKind::DeclareFunction,
            Node::DeclareHook(_) => NodeKind::DeclareHook,
            Node::DeclareComponent(_) => NodeKind::DeclareComponent,
            Node::DeclareVariable(_) => NodeKind::DeclareVariable,
            Node::DeclareEnum(_) => NodeKind::DeclareEnum,
            Node::DeclareExportDeclaration(_) => NodeKind::DeclareExportDeclaration,
            Node::DeclareExportAllDeclaration(_) => NodeKind::DeclareExportAllDeclaration,
            Node::DeclareModule(_) => NodeKind::DeclareModule,
            Node::DeclareNamespace(_) => NodeKind::DeclareNamespace,
            Node::DeclareModuleExports(_) => NodeKind::DeclareModuleExports,
            Node::InterfaceExtends(_) => NodeKind::InterfaceExtends,
            Node::ClassImplements(_) => NodeKind::ClassImplements,
            Node::TypeAnnotation(_) => NodeKind::TypeAnnotation,
            Node::ObjectTypeAnnotation(_) => NodeKind::ObjectTypeAnnotation,
            Node::ObjectTypeProperty(_) => NodeKind::ObjectTypeProperty,
            Node::ObjectTypeSpreadProperty(_) => NodeKind::ObjectTypeSpreadProperty,
            Node::ObjectTypeInternalSlot(_) => NodeKind::ObjectTypeInternalSlot,
            Node::ObjectTypeCallProperty(_) => NodeKind::ObjectTypeCallProperty,
            Node::ObjectTypeIndexer(_) => NodeKind::ObjectTypeIndexer,
            Node::ObjectTypeMappedTypeProperty(_) => NodeKind::ObjectTypeMappedTypeProperty,
            Node::Variance(_) => NodeKind::Variance,
            Node::TypeParameterDeclaration(_) => NodeKind::TypeParameterDeclaration,
            Node::TypeParameter(_) => NodeKind::TypeParameter,
            Node::TypeParameterInstantiation(_) => NodeKind::TypeParameterInstantiation,
            Node::TypeCastExpression(_) => NodeKind::TypeCastExpression,
            Node::AsExpression(_) => NodeKind::AsExpression,
            Node::AsConstExpression(_) => NodeKind::AsConstExpression,
            Node::InferredPredicate(_) => NodeKind::InferredPredicate,
            Node::DeclaredPredicate(_) => NodeKind::DeclaredPredicate,
            Node::EnumDeclaration(_) => NodeKind::EnumDeclaration,
            Node::EnumStringBody(_) => NodeKind::EnumStringBody,
            Node::EnumNumberBody(_) => NodeKind::EnumNumberBody,
            Node::EnumBigIntBody(_) => NodeKind::EnumBigIntBody,
            Node::EnumBooleanBody(_) => NodeKind::EnumBooleanBody,
            Node::EnumSymbolBody(_) => NodeKind::EnumSymbolBody,
            Node::EnumDefaultedMember(_) => NodeKind::EnumDefaultedMember,
            Node::EnumStringMember(_) => NodeKind::EnumStringMember,
            Node::EnumNumberMember(_) => NodeKind::EnumNumberMember,
            Node::EnumBigIntMember(_) => NodeKind::EnumBigIntMember,
            Node::EnumBooleanMember(_) => NodeKind::EnumBooleanMember,
            Node::ComponentParameter(_) => NodeKind::ComponentParameter,
            Node::RecordDeclaration(_) => NodeKind::RecordDeclaration,
            Node::RecordDeclarationImplements(_) => NodeKind::RecordDeclarationImplements,
            Node::RecordDeclarationBody(_) => NodeKind::RecordDeclarationBody,
            Node::RecordDeclarationProperty(_) => NodeKind::RecordDeclarationProperty,
            Node::RecordDeclarationStaticProperty(_) => NodeKind::RecordDeclarationStaticProperty,
            Node::RecordExpression(_) => NodeKind::RecordExpression,
            Node::RecordExpressionProperties(_) => NodeKind::RecordExpressionProperties,
            Node::TSTypeAnnotation(_) => NodeKind::TSTypeAnnotation,
            Node::TSAnyKeyword(_) => NodeKind::TSAnyKeyword,
            Node::TSNumberKeyword(_) => NodeKind::TSNumberKeyword,
            Node::TSBooleanKeyword(_) => NodeKind::TSBooleanKeyword,
            Node::TSStringKeyword(_) => NodeKind::TSStringKeyword,
            Node::TSSymbolKeyword(_) => NodeKind::TSSymbolKeyword,
            Node::TSVoidKeyword(_) => NodeKind::TSVoidKeyword,
            Node::TSUndefinedKeyword(_) => NodeKind::TSUndefinedKeyword,
            Node::TSUnknownKeyword(_) => NodeKind::TSUnknownKeyword,
            Node::TSNeverKeyword(_) => NodeKind::TSNeverKeyword,
            Node::TSBigIntKeyword(_) => NodeKind::TSBigIntKeyword,
            Node::TSThisType(_) => NodeKind::TSThisType,
            Node::TSLiteralType(_) => NodeKind::TSLiteralType,
            Node::TSIndexedAccessType(_) => NodeKind::TSIndexedAccessType,
            Node::TSArrayType(_) => NodeKind::TSArrayType,
            Node::TSTypeReference(_) => NodeKind::TSTypeReference,
            Node::TSQualifiedName(_) => NodeKind::TSQualifiedName,
            Node::TSFunctionType(_) => NodeKind::TSFunctionType,
            Node::TSConstructorType(_) => NodeKind::TSConstructorType,
            Node::TSTypePredicate(_) => NodeKind::TSTypePredicate,
            Node::TSTupleType(_) => NodeKind::TSTupleType,
            Node::TSTypeAssertion(_) => NodeKind::TSTypeAssertion,
            Node::TSAsExpression(_) => NodeKind::TSAsExpression,
            Node::TSParameterProperty(_) => NodeKind::TSParameterProperty,
            Node::TSTypeAliasDeclaration(_) => NodeKind::TSTypeAliasDeclaration,
            Node::TSInterfaceDeclaration(_) => NodeKind::TSInterfaceDeclaration,
            Node::TSInterfaceHeritage(_) => NodeKind::TSInterfaceHeritage,
            Node::TSInterfaceBody(_) => NodeKind::TSInterfaceBody,
            Node::TSEnumDeclaration(_) => NodeKind::TSEnumDeclaration,
            Node::TSEnumMember(_) => NodeKind::TSEnumMember,
            Node::TSModuleDeclaration(_) => NodeKind::TSModuleDeclaration,
            Node::TSModuleBlock(_) => NodeKind::TSModuleBlock,
            Node::TSModuleMember(_) => NodeKind::TSModuleMember,
            Node::TSTypeParameterDeclaration(_) => NodeKind::TSTypeParameterDeclaration,
            Node::TSTypeParameter(_) => NodeKind::TSTypeParameter,
            Node::TSTypeParameterInstantiation(_) => NodeKind::TSTypeParameterInstantiation,
            Node::TSUnionType(_) => NodeKind::TSUnionType,
            Node::TSIntersectionType(_) => NodeKind::TSIntersectionType,
            Node::TSTypeQuery(_) => NodeKind::TSTypeQuery,
            Node::TSConditionalType(_) => NodeKind::TSConditionalType,
            Node::TSTypeLiteral(_) => NodeKind::TSTypeLiteral,
            Node::TSPropertySignature(_) => NodeKind::TSPropertySignature,
            Node::TSMethodSignature(_) => NodeKind::TSMethodSignature,
            Node::TSIndexSignature(_) => NodeKind::TSIndexSignature,
            Node::TSCallSignatureDeclaration(_) => NodeKind::TSCallSignatureDeclaration,
            Node::TSModifiers(_) => NodeKind::TSModifiers,
            Node::CoverEmptyArgs(_) => NodeKind::CoverEmptyArgs,
            Node::CoverTrailingComma(_) => NodeKind::CoverTrailingComma,
            Node::CoverInitializer(_) => NodeKind::CoverInitializer,
            Node::CoverRestElement(_) => NodeKind::CoverRestElement,
            Node::CoverTypedIdentifier(_) => NodeKind::CoverTypedIdentifier,
            Node::SHBuiltin(_) => NodeKind::SHBuiltin,
            Node::ImplicitCheckedCast(_) => NodeKind::ImplicitCheckedCast,
        }
    }

    /// This node's metadata, common to every kind.
    pub fn metadata(&self) -> &NodeMetadata<'gc> {
        match self {
            Node::Empty(n) => &n.metadata,
            Node::Metadata(n) => &n.metadata,
            Node::Program(n) => &n.metadata,
            Node::FunctionExpression(n) => &n.metadata,
            Node::ArrowFunctionExpression(n) => &n.metadata,
            Node::FunctionDeclaration(n) => &n.metadata,
            Node::ComponentDeclaration(n) => &n.metadata,
            Node::HookDeclaration(n) => &n.metadata,
            Node::MatchStatement(n) => &n.metadata,
            Node::WhileStatement(n) => &n.metadata,
            Node::DoWhileStatement(n) => &n.metadata,
            Node::ForInStatement(n) => &n.metadata,
            Node::ForOfStatement(n) => &n.metadata,
            Node::ForStatement(n) => &n.metadata,
            Node::DebuggerStatement(n) => &n.metadata,
            Node::EmptyStatement(n) => &n.metadata,
            Node::BlockStatement(n) => &n.metadata,
            Node::StaticBlock(n) => &n.metadata,
            Node::BreakStatement(n) => &n.metadata,
            Node::ContinueStatement(n) => &n.metadata,
            Node::ThrowStatement(n) => &n.metadata,
            Node::ReturnStatement(n) => &n.metadata,
            Node::WithStatement(n) => &n.metadata,
            Node::SwitchStatement(n) => &n.metadata,
            Node::LabeledStatement(n) => &n.metadata,
            Node::ExpressionStatement(n) => &n.metadata,
            Node::TryStatement(n) => &n.metadata,
            Node::IfStatement(n) => &n.metadata,
            Node::NullLiteral(n) => &n.metadata,
            Node::BooleanLiteral(n) => &n.metadata,
            Node::StringLiteral(n) => &n.metadata,
            Node::NumericLiteral(n) => &n.metadata,
            Node::RegExpLiteral(n) => &n.metadata,
            Node::BigIntLiteral(n) => &n.metadata,
            Node::ThisExpression(n) => &n.metadata,
            Node::Super(n) => &n.metadata,
            Node::SequenceExpression(n) => &n.metadata,
            Node::ObjectExpression(n) => &n.metadata,
            Node::ArrayExpression(n) => &n.metadata,
            Node::SpreadElement(n) => &n.metadata,
            Node::NewExpression(n) => &n.metadata,
            Node::YieldExpression(n) => &n.metadata,
            Node::AwaitExpression(n) => &n.metadata,
            Node::ImportExpression(n) => &n.metadata,
            Node::CallExpression(n) => &n.metadata,
            Node::OptionalCallExpression(n) => &n.metadata,
            Node::AssignmentExpression(n) => &n.metadata,
            Node::UnaryExpression(n) => &n.metadata,
            Node::UpdateExpression(n) => &n.metadata,
            Node::MemberExpression(n) => &n.metadata,
            Node::OptionalMemberExpression(n) => &n.metadata,
            Node::LogicalExpression(n) => &n.metadata,
            Node::ConditionalExpression(n) => &n.metadata,
            Node::BinaryExpression(n) => &n.metadata,
            Node::Directive(n) => &n.metadata,
            Node::DirectiveLiteral(n) => &n.metadata,
            Node::Identifier(n) => &n.metadata,
            Node::PrivateName(n) => &n.metadata,
            Node::MetaProperty(n) => &n.metadata,
            Node::SwitchCase(n) => &n.metadata,
            Node::CatchClause(n) => &n.metadata,
            Node::VariableDeclarator(n) => &n.metadata,
            Node::VariableDeclaration(n) => &n.metadata,
            Node::TemplateLiteral(n) => &n.metadata,
            Node::TaggedTemplateExpression(n) => &n.metadata,
            Node::TemplateElement(n) => &n.metadata,
            Node::Property(n) => &n.metadata,
            Node::Decorator(n) => &n.metadata,
            Node::ClassDeclaration(n) => &n.metadata,
            Node::ClassExpression(n) => &n.metadata,
            Node::ClassBody(n) => &n.metadata,
            Node::ClassProperty(n) => &n.metadata,
            Node::ClassPrivateProperty(n) => &n.metadata,
            Node::MethodDefinition(n) => &n.metadata,
            Node::ImportDeclaration(n) => &n.metadata,
            Node::ImportSpecifier(n) => &n.metadata,
            Node::ImportDefaultSpecifier(n) => &n.metadata,
            Node::ImportNamespaceSpecifier(n) => &n.metadata,
            Node::ImportAttribute(n) => &n.metadata,
            Node::ExportNamedDeclaration(n) => &n.metadata,
            Node::ExportSpecifier(n) => &n.metadata,
            Node::ExportNamespaceSpecifier(n) => &n.metadata,
            Node::ExportDefaultDeclaration(n) => &n.metadata,
            Node::ExportAllDeclaration(n) => &n.metadata,
            Node::ObjectPattern(n) => &n.metadata,
            Node::ArrayPattern(n) => &n.metadata,
            Node::RestElement(n) => &n.metadata,
            Node::AssignmentPattern(n) => &n.metadata,
            Node::MatchStatementCase(n) => &n.metadata,
            Node::MatchExpression(n) => &n.metadata,
            Node::MatchExpressionCase(n) => &n.metadata,
            Node::MatchWildcardPattern(n) => &n.metadata,
            Node::MatchLiteralPattern(n) => &n.metadata,
            Node::MatchUnaryPattern(n) => &n.metadata,
            Node::MatchIdentifierPattern(n) => &n.metadata,
            Node::MatchBindingPattern(n) => &n.metadata,
            Node::MatchObjectPattern(n) => &n.metadata,
            Node::MatchArrayPattern(n) => &n.metadata,
            Node::MatchOrPattern(n) => &n.metadata,
            Node::MatchAsPattern(n) => &n.metadata,
            Node::MatchMemberPattern(n) => &n.metadata,
            Node::MatchInstancePattern(n) => &n.metadata,
            Node::MatchObjectPatternProperty(n) => &n.metadata,
            Node::MatchInstanceObjectPattern(n) => &n.metadata,
            Node::MatchRestPattern(n) => &n.metadata,
            Node::JSXIdentifier(n) => &n.metadata,
            Node::JSXMemberExpression(n) => &n.metadata,
            Node::JSXNamespacedName(n) => &n.metadata,
            Node::JSXEmptyExpression(n) => &n.metadata,
            Node::JSXExpressionContainer(n) => &n.metadata,
            Node::JSXSpreadChild(n) => &n.metadata,
            Node::JSXOpeningElement(n) => &n.metadata,
            Node::JSXClosingElement(n) => &n.metadata,
            Node::JSXAttribute(n) => &n.metadata,
            Node::JSXSpreadAttribute(n) => &n.metadata,
            Node::JSXStringLiteral(n) => &n.metadata,
            Node::JSXText(n) => &n.metadata,
            Node::JSXElement(n) => &n.metadata,
            Node::JSXFragment(n) => &n.metadata,
            Node::JSXOpeningFragment(n) => &n.metadata,
            Node::JSXClosingFragment(n) => &n.metadata,
            Node::ExistsTypeAnnotation(n) => &n.metadata,
            Node::EmptyTypeAnnotation(n) => &n.metadata,
            Node::StringTypeAnnotation(n) => &n.metadata,
            Node::NumberTypeAnnotation(n) => &n.metadata,
            Node::StringLiteralTypeAnnotation(n) => &n.metadata,
            Node::NumberLiteralTypeAnnotation(n) => &n.metadata,
            Node::BigIntLiteralTypeAnnotation(n) => &n.metadata,
            Node::BooleanTypeAnnotation(n) => &n.metadata,
            Node::BooleanLiteralTypeAnnotation(n) => &n.metadata,
            Node::NullLiteralTypeAnnotation(n) => &n.metadata,
            Node::SymbolTypeAnnotation(n) => &n.metadata,
            Node::AnyTypeAnnotation(n) => &n.metadata,
            Node::MixedTypeAnnotation(n) => &n.metadata,
            Node::BigIntTypeAnnotation(n) => &n.metadata,
            Node::VoidTypeAnnotation(n) => &n.metadata,
            Node::NeverTypeAnnotation(n) => &n.metadata,
            Node::UnknownTypeAnnotation(n) => &n.metadata,
            Node::UndefinedTypeAnnotation(n) => &n.metadata,
            Node::FunctionTypeAnnotation(n) => &n.metadata,
            Node::HookTypeAnnotation(n) => &n.metadata,
            Node::FunctionTypeParam(n) => &n.metadata,
            Node::ComponentTypeAnnotation(n) => &n.metadata,
            Node::ComponentTypeParameter(n) => &n.metadata,
            Node::NullableTypeAnnotation(n) => &n.metadata,
            Node::QualifiedTypeIdentifier(n) => &n.metadata,
            Node::TypeofTypeAnnotation(n) => &n.metadata,
            Node::KeyofTypeAnnotation(n) => &n.metadata,
            Node::TypeOperator(n) => &n.metadata,
            Node::QualifiedTypeofIdentifier(n) => &n.metadata,
            Node::TupleTypeAnnotation(n) => &n.metadata,
            Node::TupleTypeSpreadElement(n) => &n.metadata,
            Node::TupleTypeLabeledElement(n) => &n.metadata,
            Node::ArrayTypeAnnotation(n) => &n.metadata,
            Node::InferTypeAnnotation(n) => &n.metadata,
            Node::UnionTypeAnnotation(n) => &n.metadata,
            Node::IntersectionTypeAnnotation(n) => &n.metadata,
            Node::GenericTypeAnnotation(n) => &n.metadata,
            Node::IndexedAccessType(n) => &n.metadata,
            Node::OptionalIndexedAccessType(n) => &n.metadata,
            Node::ConditionalTypeAnnotation(n) => &n.metadata,
            Node::TypePredicate(n) => &n.metadata,
            Node::InterfaceTypeAnnotation(n) => &n.metadata,
            Node::TypeAlias(n) => &n.metadata,
            Node::OpaqueType(n) => &n.metadata,
            Node::InterfaceDeclaration(n) => &n.metadata,
            Node::DeclareTypeAlias(n) => &n.metadata,
            Node::DeclareOpaqueType(n) => &n.metadata,
            Node::DeclareInterface(n) => &n.metadata,
            Node::DeclareClass(n) => &n.metadata,
            Node::DeclareFunction(n) => &n.metadata,
            Node::DeclareHook(n) => &n.metadata,
            Node::DeclareComponent(n) => &n.metadata,
            Node::DeclareVariable(n) => &n.metadata,
            Node::DeclareEnum(n) => &n.metadata,
            Node::DeclareExportDeclaration(n) => &n.metadata,
            Node::DeclareExportAllDeclaration(n) => &n.metadata,
            Node::DeclareModule(n) => &n.metadata,
            Node::DeclareNamespace(n) => &n.metadata,
            Node::DeclareModuleExports(n) => &n.metadata,
            Node::InterfaceExtends(n) => &n.metadata,
            Node::ClassImplements(n) => &n.metadata,
            Node::TypeAnnotation(n) => &n.metadata,
            Node::ObjectTypeAnnotation(n) => &n.metadata,
            Node::ObjectTypeProperty(n) => &n.metadata,
            Node::ObjectTypeSpreadProperty(n) => &n.metadata,
            Node::ObjectTypeInternalSlot(n) => &n.metadata,
            Node::ObjectTypeCallProperty(n) => &n.metadata,
            Node::ObjectTypeIndexer(n) => &n.metadata,
            Node::ObjectTypeMappedTypeProperty(n) => &n.metadata,
            Node::Variance(n) => &n.metadata,
            Node::TypeParameterDeclaration(n) => &n.metadata,
            Node::TypeParameter(n) => &n.metadata,
            Node::TypeParameterInstantiation(n) => &n.metadata,
            Node::TypeCastExpression(n) => &n.metadata,
            Node::AsExpression(n) => &n.metadata,
            Node::AsConstExpression(n) => &n.metadata,
            Node::InferredPredicate(n) => &n.metadata,
            Node::DeclaredPredicate(n) => &n.metadata,
            Node::EnumDeclaration(n) => &n.metadata,
            Node::EnumStringBody(n) => &n.metadata,
            Node::EnumNumberBody(n) => &n.metadata,
            Node::EnumBigIntBody(n) => &n.metadata,
            Node::EnumBooleanBody(n) => &n.metadata,
            Node::EnumSymbolBody(n) => &n.metadata,
            Node::EnumDefaultedMember(n) => &n.metadata,
            Node::EnumStringMember(n) => &n.metadata,
            Node::EnumNumberMember(n) => &n.metadata,
            Node::EnumBigIntMember(n) => &n.metadata,
            Node::EnumBooleanMember(n) => &n.metadata,
            Node::ComponentParameter(n) => &n.metadata,
            Node::RecordDeclaration(n) => &n.metadata,
            Node::RecordDeclarationImplements(n) => &n.metadata,
            Node::RecordDeclarationBody(n) => &n.metadata,
            Node::RecordDeclarationProperty(n) => &n.metadata,
            Node::RecordDeclarationStaticProperty(n) => &n.metadata,
            Node::RecordExpression(n) => &n.metadata,
            Node::RecordExpressionProperties(n) => &n.metadata,
            Node::TSTypeAnnotation(n) => &n.metadata,
            Node::TSAnyKeyword(n) => &n.metadata,
            Node::TSNumberKeyword(n) => &n.metadata,
            Node::TSBooleanKeyword(n) => &n.metadata,
            Node::TSStringKeyword(n) => &n.metadata,
            Node::TSSymbolKeyword(n) => &n.metadata,
            Node::TSVoidKeyword(n) => &n.metadata,
            Node::TSUndefinedKeyword(n) => &n.metadata,
            Node::TSUnknownKeyword(n) => &n.metadata,
            Node::TSNeverKeyword(n) => &n.metadata,
            Node::TSBigIntKeyword(n) => &n.metadata,
            Node::TSThisType(n) => &n.metadata,
            Node::TSLiteralType(n) => &n.metadata,
            Node::TSIndexedAccessType(n) => &n.metadata,
            Node::TSArrayType(n) => &n.metadata,
            Node::TSTypeReference(n) => &n.metadata,
            Node::TSQualifiedName(n) => &n.metadata,
            Node::TSFunctionType(n) => &n.metadata,
            Node::TSConstructorType(n) => &n.metadata,
            Node::TSTypePredicate(n) => &n.metadata,
            Node::TSTupleType(n) => &n.metadata,
            Node::TSTypeAssertion(n) => &n.metadata,
            Node::TSAsExpression(n) => &n.metadata,
            Node::TSParameterProperty(n) => &n.metadata,
            Node::TSTypeAliasDeclaration(n) => &n.metadata,
            Node::TSInterfaceDeclaration(n) => &n.metadata,
            Node::TSInterfaceHeritage(n) => &n.metadata,
            Node::TSInterfaceBody(n) => &n.metadata,
            Node::TSEnumDeclaration(n) => &n.metadata,
            Node::TSEnumMember(n) => &n.metadata,
            Node::TSModuleDeclaration(n) => &n.metadata,
            Node::TSModuleBlock(n) => &n.metadata,
            Node::TSModuleMember(n) => &n.metadata,
            Node::TSTypeParameterDeclaration(n) => &n.metadata,
            Node::TSTypeParameter(n) => &n.metadata,
            Node::TSTypeParameterInstantiation(n) => &n.metadata,
            Node::TSUnionType(n) => &n.metadata,
            Node::TSIntersectionType(n) => &n.metadata,
            Node::TSTypeQuery(n) => &n.metadata,
            Node::TSConditionalType(n) => &n.metadata,
            Node::TSTypeLiteral(n) => &n.metadata,
            Node::TSPropertySignature(n) => &n.metadata,
            Node::TSMethodSignature(n) => &n.metadata,
            Node::TSIndexSignature(n) => &n.metadata,
            Node::TSCallSignatureDeclaration(n) => &n.metadata,
            Node::TSModifiers(n) => &n.metadata,
            Node::CoverEmptyArgs(n) => &n.metadata,
            Node::CoverTrailingComma(n) => &n.metadata,
            Node::CoverInitializer(n) => &n.metadata,
            Node::CoverRestElement(n) => &n.metadata,
            Node::CoverTypedIdentifier(n) => &n.metadata,
            Node::SHBuiltin(n) => &n.metadata,
            Node::ImplicitCheckedCast(n) => &n.metadata,
        }
    }

    /// This node's arena identity (see [`NodeId`]).
    pub fn node_id(&self) -> NodeId {
        self.metadata().id.get()
    }

    /// This node's source range.
    pub fn range(&self) -> hermes_support::location::SMRange {
        self.metadata().range.get()
    }

    /// Whether this node's kind is in the `FunctionLike` range.
    pub fn is_function_like(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_FunctionLike_First as u32) < k && k < (NodeKind::_FunctionLike_Last as u32)
    }

    /// Whether this node's kind is in the `Statement` range.
    pub fn is_statement(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_Statement_First as u32) < k && k < (NodeKind::_Statement_Last as u32)
    }

    /// Whether this node's kind is in the `LoopStatement` range.
    pub fn is_loop_statement(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_LoopStatement_First as u32) < k && k < (NodeKind::_LoopStatement_Last as u32)
    }

    /// Whether this node's kind is in the `CallExpressionLike` range.
    pub fn is_call_expression_like(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_CallExpressionLike_First as u32) < k && k < (NodeKind::_CallExpressionLike_Last as u32)
    }

    /// Whether this node's kind is in the `MemberExpressionLike` range.
    pub fn is_member_expression_like(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_MemberExpressionLike_First as u32) < k && k < (NodeKind::_MemberExpressionLike_Last as u32)
    }

    /// Whether this node's kind is in the `ClassLike` range.
    pub fn is_class_like(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_ClassLike_First as u32) < k && k < (NodeKind::_ClassLike_Last as u32)
    }

    /// Whether this node's kind is in the `Pattern` range.
    pub fn is_pattern(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_Pattern_First as u32) < k && k < (NodeKind::_Pattern_Last as u32)
    }

    /// Whether this node's kind is in the `MatchPattern` range.
    pub fn is_match_pattern(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_MatchPattern_First as u32) < k && k < (NodeKind::_MatchPattern_Last as u32)
    }

    /// Whether this node's kind is in the `JSX` range.
    pub fn is_jsx(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_JSX_First as u32) < k && k < (NodeKind::_JSX_Last as u32)
    }

    /// Whether this node's kind is in the `Flow` range.
    pub fn is_flow(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_Flow_First as u32) < k && k < (NodeKind::_Flow_Last as u32)
    }

    /// Whether this node's kind is in the `TS` range.
    pub fn is_ts(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_TS_First as u32) < k && k < (NodeKind::_TS_Last as u32)
    }

    /// Whether this node's kind is in the `Cover` range.
    pub fn is_cover(&self) -> bool {
        let k = self.kind() as u32;
        (NodeKind::_Cover_First as u32) < k && k < (NodeKind::_Cover_Last as u32)
    }

    /// The payload if this is a [`Empty`], `None` otherwise.
    pub fn as_empty(&self) -> Option<&Empty<'gc>> {
        if let Node::Empty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`Metadata`], `None` otherwise.
    pub fn as_metadata(&self) -> Option<&Metadata<'gc>> {
        if let Node::Metadata(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`Program`], `None` otherwise.
    pub fn as_program(&self) -> Option<&Program<'gc>> {
        if let Node::Program(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`FunctionExpression`], `None` otherwise.
    pub fn as_function_expression(&self) -> Option<&FunctionExpression<'gc>> {
        if let Node::FunctionExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ArrowFunctionExpression`], `None` otherwise.
    pub fn as_arrow_function_expression(&self) -> Option<&ArrowFunctionExpression<'gc>> {
        if let Node::ArrowFunctionExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`FunctionDeclaration`], `None` otherwise.
    pub fn as_function_declaration(&self) -> Option<&FunctionDeclaration<'gc>> {
        if let Node::FunctionDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ComponentDeclaration`], `None` otherwise.
    pub fn as_component_declaration(&self) -> Option<&ComponentDeclaration<'gc>> {
        if let Node::ComponentDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`HookDeclaration`], `None` otherwise.
    pub fn as_hook_declaration(&self) -> Option<&HookDeclaration<'gc>> {
        if let Node::HookDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchStatement`], `None` otherwise.
    pub fn as_match_statement(&self) -> Option<&MatchStatement<'gc>> {
        if let Node::MatchStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`WhileStatement`], `None` otherwise.
    pub fn as_while_statement(&self) -> Option<&WhileStatement<'gc>> {
        if let Node::WhileStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DoWhileStatement`], `None` otherwise.
    pub fn as_do_while_statement(&self) -> Option<&DoWhileStatement<'gc>> {
        if let Node::DoWhileStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ForInStatement`], `None` otherwise.
    pub fn as_for_in_statement(&self) -> Option<&ForInStatement<'gc>> {
        if let Node::ForInStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ForOfStatement`], `None` otherwise.
    pub fn as_for_of_statement(&self) -> Option<&ForOfStatement<'gc>> {
        if let Node::ForOfStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ForStatement`], `None` otherwise.
    pub fn as_for_statement(&self) -> Option<&ForStatement<'gc>> {
        if let Node::ForStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DebuggerStatement`], `None` otherwise.
    pub fn as_debugger_statement(&self) -> Option<&DebuggerStatement<'gc>> {
        if let Node::DebuggerStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EmptyStatement`], `None` otherwise.
    pub fn as_empty_statement(&self) -> Option<&EmptyStatement<'gc>> {
        if let Node::EmptyStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`BlockStatement`], `None` otherwise.
    pub fn as_block_statement(&self) -> Option<&BlockStatement<'gc>> {
        if let Node::BlockStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`StaticBlock`], `None` otherwise.
    pub fn as_static_block(&self) -> Option<&StaticBlock<'gc>> {
        if let Node::StaticBlock(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`BreakStatement`], `None` otherwise.
    pub fn as_break_statement(&self) -> Option<&BreakStatement<'gc>> {
        if let Node::BreakStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ContinueStatement`], `None` otherwise.
    pub fn as_continue_statement(&self) -> Option<&ContinueStatement<'gc>> {
        if let Node::ContinueStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ThrowStatement`], `None` otherwise.
    pub fn as_throw_statement(&self) -> Option<&ThrowStatement<'gc>> {
        if let Node::ThrowStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ReturnStatement`], `None` otherwise.
    pub fn as_return_statement(&self) -> Option<&ReturnStatement<'gc>> {
        if let Node::ReturnStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`WithStatement`], `None` otherwise.
    pub fn as_with_statement(&self) -> Option<&WithStatement<'gc>> {
        if let Node::WithStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`SwitchStatement`], `None` otherwise.
    pub fn as_switch_statement(&self) -> Option<&SwitchStatement<'gc>> {
        if let Node::SwitchStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`LabeledStatement`], `None` otherwise.
    pub fn as_labeled_statement(&self) -> Option<&LabeledStatement<'gc>> {
        if let Node::LabeledStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ExpressionStatement`], `None` otherwise.
    pub fn as_expression_statement(&self) -> Option<&ExpressionStatement<'gc>> {
        if let Node::ExpressionStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TryStatement`], `None` otherwise.
    pub fn as_try_statement(&self) -> Option<&TryStatement<'gc>> {
        if let Node::TryStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`IfStatement`], `None` otherwise.
    pub fn as_if_statement(&self) -> Option<&IfStatement<'gc>> {
        if let Node::IfStatement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`NullLiteral`], `None` otherwise.
    pub fn as_null_literal(&self) -> Option<&NullLiteral<'gc>> {
        if let Node::NullLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`BooleanLiteral`], `None` otherwise.
    pub fn as_boolean_literal(&self) -> Option<&BooleanLiteral<'gc>> {
        if let Node::BooleanLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`StringLiteral`], `None` otherwise.
    pub fn as_string_literal(&self) -> Option<&StringLiteral<'gc>> {
        if let Node::StringLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`NumericLiteral`], `None` otherwise.
    pub fn as_numeric_literal(&self) -> Option<&NumericLiteral<'gc>> {
        if let Node::NumericLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`RegExpLiteral`], `None` otherwise.
    pub fn as_reg_exp_literal(&self) -> Option<&RegExpLiteral<'gc>> {
        if let Node::RegExpLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`BigIntLiteral`], `None` otherwise.
    pub fn as_big_int_literal(&self) -> Option<&BigIntLiteral<'gc>> {
        if let Node::BigIntLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ThisExpression`], `None` otherwise.
    pub fn as_this_expression(&self) -> Option<&ThisExpression<'gc>> {
        if let Node::ThisExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`Super`], `None` otherwise.
    pub fn as_super(&self) -> Option<&Super<'gc>> {
        if let Node::Super(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`SequenceExpression`], `None` otherwise.
    pub fn as_sequence_expression(&self) -> Option<&SequenceExpression<'gc>> {
        if let Node::SequenceExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ObjectExpression`], `None` otherwise.
    pub fn as_object_expression(&self) -> Option<&ObjectExpression<'gc>> {
        if let Node::ObjectExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ArrayExpression`], `None` otherwise.
    pub fn as_array_expression(&self) -> Option<&ArrayExpression<'gc>> {
        if let Node::ArrayExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`SpreadElement`], `None` otherwise.
    pub fn as_spread_element(&self) -> Option<&SpreadElement<'gc>> {
        if let Node::SpreadElement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`NewExpression`], `None` otherwise.
    pub fn as_new_expression(&self) -> Option<&NewExpression<'gc>> {
        if let Node::NewExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`YieldExpression`], `None` otherwise.
    pub fn as_yield_expression(&self) -> Option<&YieldExpression<'gc>> {
        if let Node::YieldExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`AwaitExpression`], `None` otherwise.
    pub fn as_await_expression(&self) -> Option<&AwaitExpression<'gc>> {
        if let Node::AwaitExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ImportExpression`], `None` otherwise.
    pub fn as_import_expression(&self) -> Option<&ImportExpression<'gc>> {
        if let Node::ImportExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`CallExpression`], `None` otherwise.
    pub fn as_call_expression(&self) -> Option<&CallExpression<'gc>> {
        if let Node::CallExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`OptionalCallExpression`], `None` otherwise.
    pub fn as_optional_call_expression(&self) -> Option<&OptionalCallExpression<'gc>> {
        if let Node::OptionalCallExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`AssignmentExpression`], `None` otherwise.
    pub fn as_assignment_expression(&self) -> Option<&AssignmentExpression<'gc>> {
        if let Node::AssignmentExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`UnaryExpression`], `None` otherwise.
    pub fn as_unary_expression(&self) -> Option<&UnaryExpression<'gc>> {
        if let Node::UnaryExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`UpdateExpression`], `None` otherwise.
    pub fn as_update_expression(&self) -> Option<&UpdateExpression<'gc>> {
        if let Node::UpdateExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MemberExpression`], `None` otherwise.
    pub fn as_member_expression(&self) -> Option<&MemberExpression<'gc>> {
        if let Node::MemberExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`OptionalMemberExpression`], `None` otherwise.
    pub fn as_optional_member_expression(&self) -> Option<&OptionalMemberExpression<'gc>> {
        if let Node::OptionalMemberExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`LogicalExpression`], `None` otherwise.
    pub fn as_logical_expression(&self) -> Option<&LogicalExpression<'gc>> {
        if let Node::LogicalExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ConditionalExpression`], `None` otherwise.
    pub fn as_conditional_expression(&self) -> Option<&ConditionalExpression<'gc>> {
        if let Node::ConditionalExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`BinaryExpression`], `None` otherwise.
    pub fn as_binary_expression(&self) -> Option<&BinaryExpression<'gc>> {
        if let Node::BinaryExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`Directive`], `None` otherwise.
    pub fn as_directive(&self) -> Option<&Directive<'gc>> {
        if let Node::Directive(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DirectiveLiteral`], `None` otherwise.
    pub fn as_directive_literal(&self) -> Option<&DirectiveLiteral<'gc>> {
        if let Node::DirectiveLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`Identifier`], `None` otherwise.
    pub fn as_identifier(&self) -> Option<&Identifier<'gc>> {
        if let Node::Identifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`PrivateName`], `None` otherwise.
    pub fn as_private_name(&self) -> Option<&PrivateName<'gc>> {
        if let Node::PrivateName(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MetaProperty`], `None` otherwise.
    pub fn as_meta_property(&self) -> Option<&MetaProperty<'gc>> {
        if let Node::MetaProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`SwitchCase`], `None` otherwise.
    pub fn as_switch_case(&self) -> Option<&SwitchCase<'gc>> {
        if let Node::SwitchCase(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`CatchClause`], `None` otherwise.
    pub fn as_catch_clause(&self) -> Option<&CatchClause<'gc>> {
        if let Node::CatchClause(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`VariableDeclarator`], `None` otherwise.
    pub fn as_variable_declarator(&self) -> Option<&VariableDeclarator<'gc>> {
        if let Node::VariableDeclarator(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`VariableDeclaration`], `None` otherwise.
    pub fn as_variable_declaration(&self) -> Option<&VariableDeclaration<'gc>> {
        if let Node::VariableDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TemplateLiteral`], `None` otherwise.
    pub fn as_template_literal(&self) -> Option<&TemplateLiteral<'gc>> {
        if let Node::TemplateLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TaggedTemplateExpression`], `None` otherwise.
    pub fn as_tagged_template_expression(&self) -> Option<&TaggedTemplateExpression<'gc>> {
        if let Node::TaggedTemplateExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TemplateElement`], `None` otherwise.
    pub fn as_template_element(&self) -> Option<&TemplateElement<'gc>> {
        if let Node::TemplateElement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`Property`], `None` otherwise.
    pub fn as_property(&self) -> Option<&Property<'gc>> {
        if let Node::Property(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`Decorator`], `None` otherwise.
    pub fn as_decorator(&self) -> Option<&Decorator<'gc>> {
        if let Node::Decorator(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ClassDeclaration`], `None` otherwise.
    pub fn as_class_declaration(&self) -> Option<&ClassDeclaration<'gc>> {
        if let Node::ClassDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ClassExpression`], `None` otherwise.
    pub fn as_class_expression(&self) -> Option<&ClassExpression<'gc>> {
        if let Node::ClassExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ClassBody`], `None` otherwise.
    pub fn as_class_body(&self) -> Option<&ClassBody<'gc>> {
        if let Node::ClassBody(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ClassProperty`], `None` otherwise.
    pub fn as_class_property(&self) -> Option<&ClassProperty<'gc>> {
        if let Node::ClassProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ClassPrivateProperty`], `None` otherwise.
    pub fn as_class_private_property(&self) -> Option<&ClassPrivateProperty<'gc>> {
        if let Node::ClassPrivateProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MethodDefinition`], `None` otherwise.
    pub fn as_method_definition(&self) -> Option<&MethodDefinition<'gc>> {
        if let Node::MethodDefinition(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ImportDeclaration`], `None` otherwise.
    pub fn as_import_declaration(&self) -> Option<&ImportDeclaration<'gc>> {
        if let Node::ImportDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ImportSpecifier`], `None` otherwise.
    pub fn as_import_specifier(&self) -> Option<&ImportSpecifier<'gc>> {
        if let Node::ImportSpecifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ImportDefaultSpecifier`], `None` otherwise.
    pub fn as_import_default_specifier(&self) -> Option<&ImportDefaultSpecifier<'gc>> {
        if let Node::ImportDefaultSpecifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ImportNamespaceSpecifier`], `None` otherwise.
    pub fn as_import_namespace_specifier(&self) -> Option<&ImportNamespaceSpecifier<'gc>> {
        if let Node::ImportNamespaceSpecifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ImportAttribute`], `None` otherwise.
    pub fn as_import_attribute(&self) -> Option<&ImportAttribute<'gc>> {
        if let Node::ImportAttribute(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ExportNamedDeclaration`], `None` otherwise.
    pub fn as_export_named_declaration(&self) -> Option<&ExportNamedDeclaration<'gc>> {
        if let Node::ExportNamedDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ExportSpecifier`], `None` otherwise.
    pub fn as_export_specifier(&self) -> Option<&ExportSpecifier<'gc>> {
        if let Node::ExportSpecifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ExportNamespaceSpecifier`], `None` otherwise.
    pub fn as_export_namespace_specifier(&self) -> Option<&ExportNamespaceSpecifier<'gc>> {
        if let Node::ExportNamespaceSpecifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ExportDefaultDeclaration`], `None` otherwise.
    pub fn as_export_default_declaration(&self) -> Option<&ExportDefaultDeclaration<'gc>> {
        if let Node::ExportDefaultDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ExportAllDeclaration`], `None` otherwise.
    pub fn as_export_all_declaration(&self) -> Option<&ExportAllDeclaration<'gc>> {
        if let Node::ExportAllDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ObjectPattern`], `None` otherwise.
    pub fn as_object_pattern(&self) -> Option<&ObjectPattern<'gc>> {
        if let Node::ObjectPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ArrayPattern`], `None` otherwise.
    pub fn as_array_pattern(&self) -> Option<&ArrayPattern<'gc>> {
        if let Node::ArrayPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`RestElement`], `None` otherwise.
    pub fn as_rest_element(&self) -> Option<&RestElement<'gc>> {
        if let Node::RestElement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`AssignmentPattern`], `None` otherwise.
    pub fn as_assignment_pattern(&self) -> Option<&AssignmentPattern<'gc>> {
        if let Node::AssignmentPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchStatementCase`], `None` otherwise.
    pub fn as_match_statement_case(&self) -> Option<&MatchStatementCase<'gc>> {
        if let Node::MatchStatementCase(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchExpression`], `None` otherwise.
    pub fn as_match_expression(&self) -> Option<&MatchExpression<'gc>> {
        if let Node::MatchExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchExpressionCase`], `None` otherwise.
    pub fn as_match_expression_case(&self) -> Option<&MatchExpressionCase<'gc>> {
        if let Node::MatchExpressionCase(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchWildcardPattern`], `None` otherwise.
    pub fn as_match_wildcard_pattern(&self) -> Option<&MatchWildcardPattern<'gc>> {
        if let Node::MatchWildcardPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchLiteralPattern`], `None` otherwise.
    pub fn as_match_literal_pattern(&self) -> Option<&MatchLiteralPattern<'gc>> {
        if let Node::MatchLiteralPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchUnaryPattern`], `None` otherwise.
    pub fn as_match_unary_pattern(&self) -> Option<&MatchUnaryPattern<'gc>> {
        if let Node::MatchUnaryPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchIdentifierPattern`], `None` otherwise.
    pub fn as_match_identifier_pattern(&self) -> Option<&MatchIdentifierPattern<'gc>> {
        if let Node::MatchIdentifierPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchBindingPattern`], `None` otherwise.
    pub fn as_match_binding_pattern(&self) -> Option<&MatchBindingPattern<'gc>> {
        if let Node::MatchBindingPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchObjectPattern`], `None` otherwise.
    pub fn as_match_object_pattern(&self) -> Option<&MatchObjectPattern<'gc>> {
        if let Node::MatchObjectPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchArrayPattern`], `None` otherwise.
    pub fn as_match_array_pattern(&self) -> Option<&MatchArrayPattern<'gc>> {
        if let Node::MatchArrayPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchOrPattern`], `None` otherwise.
    pub fn as_match_or_pattern(&self) -> Option<&MatchOrPattern<'gc>> {
        if let Node::MatchOrPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchAsPattern`], `None` otherwise.
    pub fn as_match_as_pattern(&self) -> Option<&MatchAsPattern<'gc>> {
        if let Node::MatchAsPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchMemberPattern`], `None` otherwise.
    pub fn as_match_member_pattern(&self) -> Option<&MatchMemberPattern<'gc>> {
        if let Node::MatchMemberPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchInstancePattern`], `None` otherwise.
    pub fn as_match_instance_pattern(&self) -> Option<&MatchInstancePattern<'gc>> {
        if let Node::MatchInstancePattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchObjectPatternProperty`], `None`
    /// otherwise.
    pub fn as_match_object_pattern_property(&self) -> Option<&MatchObjectPatternProperty<'gc>> {
        if let Node::MatchObjectPatternProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchInstanceObjectPattern`], `None`
    /// otherwise.
    pub fn as_match_instance_object_pattern(&self) -> Option<&MatchInstanceObjectPattern<'gc>> {
        if let Node::MatchInstanceObjectPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MatchRestPattern`], `None` otherwise.
    pub fn as_match_rest_pattern(&self) -> Option<&MatchRestPattern<'gc>> {
        if let Node::MatchRestPattern(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXIdentifier`], `None` otherwise.
    pub fn as_jsx_identifier(&self) -> Option<&JSXIdentifier<'gc>> {
        if let Node::JSXIdentifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXMemberExpression`], `None` otherwise.
    pub fn as_jsx_member_expression(&self) -> Option<&JSXMemberExpression<'gc>> {
        if let Node::JSXMemberExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXNamespacedName`], `None` otherwise.
    pub fn as_jsx_namespaced_name(&self) -> Option<&JSXNamespacedName<'gc>> {
        if let Node::JSXNamespacedName(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXEmptyExpression`], `None` otherwise.
    pub fn as_jsx_empty_expression(&self) -> Option<&JSXEmptyExpression<'gc>> {
        if let Node::JSXEmptyExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXExpressionContainer`], `None` otherwise.
    pub fn as_jsx_expression_container(&self) -> Option<&JSXExpressionContainer<'gc>> {
        if let Node::JSXExpressionContainer(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXSpreadChild`], `None` otherwise.
    pub fn as_jsx_spread_child(&self) -> Option<&JSXSpreadChild<'gc>> {
        if let Node::JSXSpreadChild(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXOpeningElement`], `None` otherwise.
    pub fn as_jsx_opening_element(&self) -> Option<&JSXOpeningElement<'gc>> {
        if let Node::JSXOpeningElement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXClosingElement`], `None` otherwise.
    pub fn as_jsx_closing_element(&self) -> Option<&JSXClosingElement<'gc>> {
        if let Node::JSXClosingElement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXAttribute`], `None` otherwise.
    pub fn as_jsx_attribute(&self) -> Option<&JSXAttribute<'gc>> {
        if let Node::JSXAttribute(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXSpreadAttribute`], `None` otherwise.
    pub fn as_jsx_spread_attribute(&self) -> Option<&JSXSpreadAttribute<'gc>> {
        if let Node::JSXSpreadAttribute(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXStringLiteral`], `None` otherwise.
    pub fn as_jsx_string_literal(&self) -> Option<&JSXStringLiteral<'gc>> {
        if let Node::JSXStringLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXText`], `None` otherwise.
    pub fn as_jsx_text(&self) -> Option<&JSXText<'gc>> {
        if let Node::JSXText(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXElement`], `None` otherwise.
    pub fn as_jsx_element(&self) -> Option<&JSXElement<'gc>> {
        if let Node::JSXElement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXFragment`], `None` otherwise.
    pub fn as_jsx_fragment(&self) -> Option<&JSXFragment<'gc>> {
        if let Node::JSXFragment(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXOpeningFragment`], `None` otherwise.
    pub fn as_jsx_opening_fragment(&self) -> Option<&JSXOpeningFragment<'gc>> {
        if let Node::JSXOpeningFragment(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`JSXClosingFragment`], `None` otherwise.
    pub fn as_jsx_closing_fragment(&self) -> Option<&JSXClosingFragment<'gc>> {
        if let Node::JSXClosingFragment(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ExistsTypeAnnotation`], `None` otherwise.
    pub fn as_exists_type_annotation(&self) -> Option<&ExistsTypeAnnotation<'gc>> {
        if let Node::ExistsTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EmptyTypeAnnotation`], `None` otherwise.
    pub fn as_empty_type_annotation(&self) -> Option<&EmptyTypeAnnotation<'gc>> {
        if let Node::EmptyTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`StringTypeAnnotation`], `None` otherwise.
    pub fn as_string_type_annotation(&self) -> Option<&StringTypeAnnotation<'gc>> {
        if let Node::StringTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`NumberTypeAnnotation`], `None` otherwise.
    pub fn as_number_type_annotation(&self) -> Option<&NumberTypeAnnotation<'gc>> {
        if let Node::NumberTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`StringLiteralTypeAnnotation`], `None`
    /// otherwise.
    pub fn as_string_literal_type_annotation(&self) -> Option<&StringLiteralTypeAnnotation<'gc>> {
        if let Node::StringLiteralTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`NumberLiteralTypeAnnotation`], `None`
    /// otherwise.
    pub fn as_number_literal_type_annotation(&self) -> Option<&NumberLiteralTypeAnnotation<'gc>> {
        if let Node::NumberLiteralTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`BigIntLiteralTypeAnnotation`], `None`
    /// otherwise.
    pub fn as_big_int_literal_type_annotation(&self) -> Option<&BigIntLiteralTypeAnnotation<'gc>> {
        if let Node::BigIntLiteralTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`BooleanTypeAnnotation`], `None` otherwise.
    pub fn as_boolean_type_annotation(&self) -> Option<&BooleanTypeAnnotation<'gc>> {
        if let Node::BooleanTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`BooleanLiteralTypeAnnotation`], `None`
    /// otherwise.
    pub fn as_boolean_literal_type_annotation(&self) -> Option<&BooleanLiteralTypeAnnotation<'gc>> {
        if let Node::BooleanLiteralTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`NullLiteralTypeAnnotation`], `None`
    /// otherwise.
    pub fn as_null_literal_type_annotation(&self) -> Option<&NullLiteralTypeAnnotation<'gc>> {
        if let Node::NullLiteralTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`SymbolTypeAnnotation`], `None` otherwise.
    pub fn as_symbol_type_annotation(&self) -> Option<&SymbolTypeAnnotation<'gc>> {
        if let Node::SymbolTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`AnyTypeAnnotation`], `None` otherwise.
    pub fn as_any_type_annotation(&self) -> Option<&AnyTypeAnnotation<'gc>> {
        if let Node::AnyTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`MixedTypeAnnotation`], `None` otherwise.
    pub fn as_mixed_type_annotation(&self) -> Option<&MixedTypeAnnotation<'gc>> {
        if let Node::MixedTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`BigIntTypeAnnotation`], `None` otherwise.
    pub fn as_big_int_type_annotation(&self) -> Option<&BigIntTypeAnnotation<'gc>> {
        if let Node::BigIntTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`VoidTypeAnnotation`], `None` otherwise.
    pub fn as_void_type_annotation(&self) -> Option<&VoidTypeAnnotation<'gc>> {
        if let Node::VoidTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`NeverTypeAnnotation`], `None` otherwise.
    pub fn as_never_type_annotation(&self) -> Option<&NeverTypeAnnotation<'gc>> {
        if let Node::NeverTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`UnknownTypeAnnotation`], `None` otherwise.
    pub fn as_unknown_type_annotation(&self) -> Option<&UnknownTypeAnnotation<'gc>> {
        if let Node::UnknownTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`UndefinedTypeAnnotation`], `None` otherwise.
    pub fn as_undefined_type_annotation(&self) -> Option<&UndefinedTypeAnnotation<'gc>> {
        if let Node::UndefinedTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`FunctionTypeAnnotation`], `None` otherwise.
    pub fn as_function_type_annotation(&self) -> Option<&FunctionTypeAnnotation<'gc>> {
        if let Node::FunctionTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`HookTypeAnnotation`], `None` otherwise.
    pub fn as_hook_type_annotation(&self) -> Option<&HookTypeAnnotation<'gc>> {
        if let Node::HookTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`FunctionTypeParam`], `None` otherwise.
    pub fn as_function_type_param(&self) -> Option<&FunctionTypeParam<'gc>> {
        if let Node::FunctionTypeParam(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ComponentTypeAnnotation`], `None` otherwise.
    pub fn as_component_type_annotation(&self) -> Option<&ComponentTypeAnnotation<'gc>> {
        if let Node::ComponentTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ComponentTypeParameter`], `None` otherwise.
    pub fn as_component_type_parameter(&self) -> Option<&ComponentTypeParameter<'gc>> {
        if let Node::ComponentTypeParameter(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`NullableTypeAnnotation`], `None` otherwise.
    pub fn as_nullable_type_annotation(&self) -> Option<&NullableTypeAnnotation<'gc>> {
        if let Node::NullableTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`QualifiedTypeIdentifier`], `None` otherwise.
    pub fn as_qualified_type_identifier(&self) -> Option<&QualifiedTypeIdentifier<'gc>> {
        if let Node::QualifiedTypeIdentifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TypeofTypeAnnotation`], `None` otherwise.
    pub fn as_typeof_type_annotation(&self) -> Option<&TypeofTypeAnnotation<'gc>> {
        if let Node::TypeofTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`KeyofTypeAnnotation`], `None` otherwise.
    pub fn as_keyof_type_annotation(&self) -> Option<&KeyofTypeAnnotation<'gc>> {
        if let Node::KeyofTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TypeOperator`], `None` otherwise.
    pub fn as_type_operator(&self) -> Option<&TypeOperator<'gc>> {
        if let Node::TypeOperator(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`QualifiedTypeofIdentifier`], `None`
    /// otherwise.
    pub fn as_qualified_typeof_identifier(&self) -> Option<&QualifiedTypeofIdentifier<'gc>> {
        if let Node::QualifiedTypeofIdentifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TupleTypeAnnotation`], `None` otherwise.
    pub fn as_tuple_type_annotation(&self) -> Option<&TupleTypeAnnotation<'gc>> {
        if let Node::TupleTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TupleTypeSpreadElement`], `None` otherwise.
    pub fn as_tuple_type_spread_element(&self) -> Option<&TupleTypeSpreadElement<'gc>> {
        if let Node::TupleTypeSpreadElement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TupleTypeLabeledElement`], `None` otherwise.
    pub fn as_tuple_type_labeled_element(&self) -> Option<&TupleTypeLabeledElement<'gc>> {
        if let Node::TupleTypeLabeledElement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ArrayTypeAnnotation`], `None` otherwise.
    pub fn as_array_type_annotation(&self) -> Option<&ArrayTypeAnnotation<'gc>> {
        if let Node::ArrayTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`InferTypeAnnotation`], `None` otherwise.
    pub fn as_infer_type_annotation(&self) -> Option<&InferTypeAnnotation<'gc>> {
        if let Node::InferTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`UnionTypeAnnotation`], `None` otherwise.
    pub fn as_union_type_annotation(&self) -> Option<&UnionTypeAnnotation<'gc>> {
        if let Node::UnionTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`IntersectionTypeAnnotation`], `None`
    /// otherwise.
    pub fn as_intersection_type_annotation(&self) -> Option<&IntersectionTypeAnnotation<'gc>> {
        if let Node::IntersectionTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`GenericTypeAnnotation`], `None` otherwise.
    pub fn as_generic_type_annotation(&self) -> Option<&GenericTypeAnnotation<'gc>> {
        if let Node::GenericTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`IndexedAccessType`], `None` otherwise.
    pub fn as_indexed_access_type(&self) -> Option<&IndexedAccessType<'gc>> {
        if let Node::IndexedAccessType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`OptionalIndexedAccessType`], `None`
    /// otherwise.
    pub fn as_optional_indexed_access_type(&self) -> Option<&OptionalIndexedAccessType<'gc>> {
        if let Node::OptionalIndexedAccessType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ConditionalTypeAnnotation`], `None`
    /// otherwise.
    pub fn as_conditional_type_annotation(&self) -> Option<&ConditionalTypeAnnotation<'gc>> {
        if let Node::ConditionalTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TypePredicate`], `None` otherwise.
    pub fn as_type_predicate(&self) -> Option<&TypePredicate<'gc>> {
        if let Node::TypePredicate(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`InterfaceTypeAnnotation`], `None` otherwise.
    pub fn as_interface_type_annotation(&self) -> Option<&InterfaceTypeAnnotation<'gc>> {
        if let Node::InterfaceTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TypeAlias`], `None` otherwise.
    pub fn as_type_alias(&self) -> Option<&TypeAlias<'gc>> {
        if let Node::TypeAlias(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`OpaqueType`], `None` otherwise.
    pub fn as_opaque_type(&self) -> Option<&OpaqueType<'gc>> {
        if let Node::OpaqueType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`InterfaceDeclaration`], `None` otherwise.
    pub fn as_interface_declaration(&self) -> Option<&InterfaceDeclaration<'gc>> {
        if let Node::InterfaceDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareTypeAlias`], `None` otherwise.
    pub fn as_declare_type_alias(&self) -> Option<&DeclareTypeAlias<'gc>> {
        if let Node::DeclareTypeAlias(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareOpaqueType`], `None` otherwise.
    pub fn as_declare_opaque_type(&self) -> Option<&DeclareOpaqueType<'gc>> {
        if let Node::DeclareOpaqueType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareInterface`], `None` otherwise.
    pub fn as_declare_interface(&self) -> Option<&DeclareInterface<'gc>> {
        if let Node::DeclareInterface(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareClass`], `None` otherwise.
    pub fn as_declare_class(&self) -> Option<&DeclareClass<'gc>> {
        if let Node::DeclareClass(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareFunction`], `None` otherwise.
    pub fn as_declare_function(&self) -> Option<&DeclareFunction<'gc>> {
        if let Node::DeclareFunction(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareHook`], `None` otherwise.
    pub fn as_declare_hook(&self) -> Option<&DeclareHook<'gc>> {
        if let Node::DeclareHook(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareComponent`], `None` otherwise.
    pub fn as_declare_component(&self) -> Option<&DeclareComponent<'gc>> {
        if let Node::DeclareComponent(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareVariable`], `None` otherwise.
    pub fn as_declare_variable(&self) -> Option<&DeclareVariable<'gc>> {
        if let Node::DeclareVariable(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareEnum`], `None` otherwise.
    pub fn as_declare_enum(&self) -> Option<&DeclareEnum<'gc>> {
        if let Node::DeclareEnum(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareExportDeclaration`], `None` otherwise.
    pub fn as_declare_export_declaration(&self) -> Option<&DeclareExportDeclaration<'gc>> {
        if let Node::DeclareExportDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareExportAllDeclaration`], `None`
    /// otherwise.
    pub fn as_declare_export_all_declaration(&self) -> Option<&DeclareExportAllDeclaration<'gc>> {
        if let Node::DeclareExportAllDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareModule`], `None` otherwise.
    pub fn as_declare_module(&self) -> Option<&DeclareModule<'gc>> {
        if let Node::DeclareModule(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareNamespace`], `None` otherwise.
    pub fn as_declare_namespace(&self) -> Option<&DeclareNamespace<'gc>> {
        if let Node::DeclareNamespace(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclareModuleExports`], `None` otherwise.
    pub fn as_declare_module_exports(&self) -> Option<&DeclareModuleExports<'gc>> {
        if let Node::DeclareModuleExports(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`InterfaceExtends`], `None` otherwise.
    pub fn as_interface_extends(&self) -> Option<&InterfaceExtends<'gc>> {
        if let Node::InterfaceExtends(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ClassImplements`], `None` otherwise.
    pub fn as_class_implements(&self) -> Option<&ClassImplements<'gc>> {
        if let Node::ClassImplements(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TypeAnnotation`], `None` otherwise.
    pub fn as_type_annotation(&self) -> Option<&TypeAnnotation<'gc>> {
        if let Node::TypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ObjectTypeAnnotation`], `None` otherwise.
    pub fn as_object_type_annotation(&self) -> Option<&ObjectTypeAnnotation<'gc>> {
        if let Node::ObjectTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ObjectTypeProperty`], `None` otherwise.
    pub fn as_object_type_property(&self) -> Option<&ObjectTypeProperty<'gc>> {
        if let Node::ObjectTypeProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ObjectTypeSpreadProperty`], `None` otherwise.
    pub fn as_object_type_spread_property(&self) -> Option<&ObjectTypeSpreadProperty<'gc>> {
        if let Node::ObjectTypeSpreadProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ObjectTypeInternalSlot`], `None` otherwise.
    pub fn as_object_type_internal_slot(&self) -> Option<&ObjectTypeInternalSlot<'gc>> {
        if let Node::ObjectTypeInternalSlot(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ObjectTypeCallProperty`], `None` otherwise.
    pub fn as_object_type_call_property(&self) -> Option<&ObjectTypeCallProperty<'gc>> {
        if let Node::ObjectTypeCallProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ObjectTypeIndexer`], `None` otherwise.
    pub fn as_object_type_indexer(&self) -> Option<&ObjectTypeIndexer<'gc>> {
        if let Node::ObjectTypeIndexer(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ObjectTypeMappedTypeProperty`], `None`
    /// otherwise.
    pub fn as_object_type_mapped_type_property(&self) -> Option<&ObjectTypeMappedTypeProperty<'gc>> {
        if let Node::ObjectTypeMappedTypeProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`Variance`], `None` otherwise.
    pub fn as_variance(&self) -> Option<&Variance<'gc>> {
        if let Node::Variance(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TypeParameterDeclaration`], `None` otherwise.
    pub fn as_type_parameter_declaration(&self) -> Option<&TypeParameterDeclaration<'gc>> {
        if let Node::TypeParameterDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TypeParameter`], `None` otherwise.
    pub fn as_type_parameter(&self) -> Option<&TypeParameter<'gc>> {
        if let Node::TypeParameter(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TypeParameterInstantiation`], `None`
    /// otherwise.
    pub fn as_type_parameter_instantiation(&self) -> Option<&TypeParameterInstantiation<'gc>> {
        if let Node::TypeParameterInstantiation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TypeCastExpression`], `None` otherwise.
    pub fn as_type_cast_expression(&self) -> Option<&TypeCastExpression<'gc>> {
        if let Node::TypeCastExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`AsExpression`], `None` otherwise.
    pub fn as_as_expression(&self) -> Option<&AsExpression<'gc>> {
        if let Node::AsExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`AsConstExpression`], `None` otherwise.
    pub fn as_as_const_expression(&self) -> Option<&AsConstExpression<'gc>> {
        if let Node::AsConstExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`InferredPredicate`], `None` otherwise.
    pub fn as_inferred_predicate(&self) -> Option<&InferredPredicate<'gc>> {
        if let Node::InferredPredicate(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`DeclaredPredicate`], `None` otherwise.
    pub fn as_declared_predicate(&self) -> Option<&DeclaredPredicate<'gc>> {
        if let Node::DeclaredPredicate(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumDeclaration`], `None` otherwise.
    pub fn as_enum_declaration(&self) -> Option<&EnumDeclaration<'gc>> {
        if let Node::EnumDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumStringBody`], `None` otherwise.
    pub fn as_enum_string_body(&self) -> Option<&EnumStringBody<'gc>> {
        if let Node::EnumStringBody(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumNumberBody`], `None` otherwise.
    pub fn as_enum_number_body(&self) -> Option<&EnumNumberBody<'gc>> {
        if let Node::EnumNumberBody(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumBigIntBody`], `None` otherwise.
    pub fn as_enum_big_int_body(&self) -> Option<&EnumBigIntBody<'gc>> {
        if let Node::EnumBigIntBody(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumBooleanBody`], `None` otherwise.
    pub fn as_enum_boolean_body(&self) -> Option<&EnumBooleanBody<'gc>> {
        if let Node::EnumBooleanBody(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumSymbolBody`], `None` otherwise.
    pub fn as_enum_symbol_body(&self) -> Option<&EnumSymbolBody<'gc>> {
        if let Node::EnumSymbolBody(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumDefaultedMember`], `None` otherwise.
    pub fn as_enum_defaulted_member(&self) -> Option<&EnumDefaultedMember<'gc>> {
        if let Node::EnumDefaultedMember(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumStringMember`], `None` otherwise.
    pub fn as_enum_string_member(&self) -> Option<&EnumStringMember<'gc>> {
        if let Node::EnumStringMember(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumNumberMember`], `None` otherwise.
    pub fn as_enum_number_member(&self) -> Option<&EnumNumberMember<'gc>> {
        if let Node::EnumNumberMember(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumBigIntMember`], `None` otherwise.
    pub fn as_enum_big_int_member(&self) -> Option<&EnumBigIntMember<'gc>> {
        if let Node::EnumBigIntMember(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`EnumBooleanMember`], `None` otherwise.
    pub fn as_enum_boolean_member(&self) -> Option<&EnumBooleanMember<'gc>> {
        if let Node::EnumBooleanMember(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ComponentParameter`], `None` otherwise.
    pub fn as_component_parameter(&self) -> Option<&ComponentParameter<'gc>> {
        if let Node::ComponentParameter(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`RecordDeclaration`], `None` otherwise.
    pub fn as_record_declaration(&self) -> Option<&RecordDeclaration<'gc>> {
        if let Node::RecordDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`RecordDeclarationImplements`], `None`
    /// otherwise.
    pub fn as_record_declaration_implements(&self) -> Option<&RecordDeclarationImplements<'gc>> {
        if let Node::RecordDeclarationImplements(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`RecordDeclarationBody`], `None` otherwise.
    pub fn as_record_declaration_body(&self) -> Option<&RecordDeclarationBody<'gc>> {
        if let Node::RecordDeclarationBody(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`RecordDeclarationProperty`], `None`
    /// otherwise.
    pub fn as_record_declaration_property(&self) -> Option<&RecordDeclarationProperty<'gc>> {
        if let Node::RecordDeclarationProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`RecordDeclarationStaticProperty`], `None`
    /// otherwise.
    pub fn as_record_declaration_static_property(&self) -> Option<&RecordDeclarationStaticProperty<'gc>> {
        if let Node::RecordDeclarationStaticProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`RecordExpression`], `None` otherwise.
    pub fn as_record_expression(&self) -> Option<&RecordExpression<'gc>> {
        if let Node::RecordExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`RecordExpressionProperties`], `None`
    /// otherwise.
    pub fn as_record_expression_properties(&self) -> Option<&RecordExpressionProperties<'gc>> {
        if let Node::RecordExpressionProperties(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypeAnnotation`], `None` otherwise.
    pub fn as_ts_type_annotation(&self) -> Option<&TSTypeAnnotation<'gc>> {
        if let Node::TSTypeAnnotation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSAnyKeyword`], `None` otherwise.
    pub fn as_ts_any_keyword(&self) -> Option<&TSAnyKeyword<'gc>> {
        if let Node::TSAnyKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSNumberKeyword`], `None` otherwise.
    pub fn as_ts_number_keyword(&self) -> Option<&TSNumberKeyword<'gc>> {
        if let Node::TSNumberKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSBooleanKeyword`], `None` otherwise.
    pub fn as_ts_boolean_keyword(&self) -> Option<&TSBooleanKeyword<'gc>> {
        if let Node::TSBooleanKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSStringKeyword`], `None` otherwise.
    pub fn as_ts_string_keyword(&self) -> Option<&TSStringKeyword<'gc>> {
        if let Node::TSStringKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSSymbolKeyword`], `None` otherwise.
    pub fn as_ts_symbol_keyword(&self) -> Option<&TSSymbolKeyword<'gc>> {
        if let Node::TSSymbolKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSVoidKeyword`], `None` otherwise.
    pub fn as_ts_void_keyword(&self) -> Option<&TSVoidKeyword<'gc>> {
        if let Node::TSVoidKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSUndefinedKeyword`], `None` otherwise.
    pub fn as_ts_undefined_keyword(&self) -> Option<&TSUndefinedKeyword<'gc>> {
        if let Node::TSUndefinedKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSUnknownKeyword`], `None` otherwise.
    pub fn as_ts_unknown_keyword(&self) -> Option<&TSUnknownKeyword<'gc>> {
        if let Node::TSUnknownKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSNeverKeyword`], `None` otherwise.
    pub fn as_ts_never_keyword(&self) -> Option<&TSNeverKeyword<'gc>> {
        if let Node::TSNeverKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSBigIntKeyword`], `None` otherwise.
    pub fn as_ts_big_int_keyword(&self) -> Option<&TSBigIntKeyword<'gc>> {
        if let Node::TSBigIntKeyword(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSThisType`], `None` otherwise.
    pub fn as_ts_this_type(&self) -> Option<&TSThisType<'gc>> {
        if let Node::TSThisType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSLiteralType`], `None` otherwise.
    pub fn as_ts_literal_type(&self) -> Option<&TSLiteralType<'gc>> {
        if let Node::TSLiteralType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSIndexedAccessType`], `None` otherwise.
    pub fn as_ts_indexed_access_type(&self) -> Option<&TSIndexedAccessType<'gc>> {
        if let Node::TSIndexedAccessType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSArrayType`], `None` otherwise.
    pub fn as_ts_array_type(&self) -> Option<&TSArrayType<'gc>> {
        if let Node::TSArrayType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypeReference`], `None` otherwise.
    pub fn as_ts_type_reference(&self) -> Option<&TSTypeReference<'gc>> {
        if let Node::TSTypeReference(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSQualifiedName`], `None` otherwise.
    pub fn as_ts_qualified_name(&self) -> Option<&TSQualifiedName<'gc>> {
        if let Node::TSQualifiedName(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSFunctionType`], `None` otherwise.
    pub fn as_ts_function_type(&self) -> Option<&TSFunctionType<'gc>> {
        if let Node::TSFunctionType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSConstructorType`], `None` otherwise.
    pub fn as_ts_constructor_type(&self) -> Option<&TSConstructorType<'gc>> {
        if let Node::TSConstructorType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypePredicate`], `None` otherwise.
    pub fn as_ts_type_predicate(&self) -> Option<&TSTypePredicate<'gc>> {
        if let Node::TSTypePredicate(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTupleType`], `None` otherwise.
    pub fn as_ts_tuple_type(&self) -> Option<&TSTupleType<'gc>> {
        if let Node::TSTupleType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypeAssertion`], `None` otherwise.
    pub fn as_ts_type_assertion(&self) -> Option<&TSTypeAssertion<'gc>> {
        if let Node::TSTypeAssertion(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSAsExpression`], `None` otherwise.
    pub fn as_ts_as_expression(&self) -> Option<&TSAsExpression<'gc>> {
        if let Node::TSAsExpression(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSParameterProperty`], `None` otherwise.
    pub fn as_ts_parameter_property(&self) -> Option<&TSParameterProperty<'gc>> {
        if let Node::TSParameterProperty(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypeAliasDeclaration`], `None` otherwise.
    pub fn as_ts_type_alias_declaration(&self) -> Option<&TSTypeAliasDeclaration<'gc>> {
        if let Node::TSTypeAliasDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSInterfaceDeclaration`], `None` otherwise.
    pub fn as_ts_interface_declaration(&self) -> Option<&TSInterfaceDeclaration<'gc>> {
        if let Node::TSInterfaceDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSInterfaceHeritage`], `None` otherwise.
    pub fn as_ts_interface_heritage(&self) -> Option<&TSInterfaceHeritage<'gc>> {
        if let Node::TSInterfaceHeritage(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSInterfaceBody`], `None` otherwise.
    pub fn as_ts_interface_body(&self) -> Option<&TSInterfaceBody<'gc>> {
        if let Node::TSInterfaceBody(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSEnumDeclaration`], `None` otherwise.
    pub fn as_ts_enum_declaration(&self) -> Option<&TSEnumDeclaration<'gc>> {
        if let Node::TSEnumDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSEnumMember`], `None` otherwise.
    pub fn as_ts_enum_member(&self) -> Option<&TSEnumMember<'gc>> {
        if let Node::TSEnumMember(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSModuleDeclaration`], `None` otherwise.
    pub fn as_ts_module_declaration(&self) -> Option<&TSModuleDeclaration<'gc>> {
        if let Node::TSModuleDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSModuleBlock`], `None` otherwise.
    pub fn as_ts_module_block(&self) -> Option<&TSModuleBlock<'gc>> {
        if let Node::TSModuleBlock(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSModuleMember`], `None` otherwise.
    pub fn as_ts_module_member(&self) -> Option<&TSModuleMember<'gc>> {
        if let Node::TSModuleMember(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypeParameterDeclaration`], `None`
    /// otherwise.
    pub fn as_ts_type_parameter_declaration(&self) -> Option<&TSTypeParameterDeclaration<'gc>> {
        if let Node::TSTypeParameterDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypeParameter`], `None` otherwise.
    pub fn as_ts_type_parameter(&self) -> Option<&TSTypeParameter<'gc>> {
        if let Node::TSTypeParameter(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypeParameterInstantiation`], `None`
    /// otherwise.
    pub fn as_ts_type_parameter_instantiation(&self) -> Option<&TSTypeParameterInstantiation<'gc>> {
        if let Node::TSTypeParameterInstantiation(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSUnionType`], `None` otherwise.
    pub fn as_ts_union_type(&self) -> Option<&TSUnionType<'gc>> {
        if let Node::TSUnionType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSIntersectionType`], `None` otherwise.
    pub fn as_ts_intersection_type(&self) -> Option<&TSIntersectionType<'gc>> {
        if let Node::TSIntersectionType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypeQuery`], `None` otherwise.
    pub fn as_ts_type_query(&self) -> Option<&TSTypeQuery<'gc>> {
        if let Node::TSTypeQuery(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSConditionalType`], `None` otherwise.
    pub fn as_ts_conditional_type(&self) -> Option<&TSConditionalType<'gc>> {
        if let Node::TSConditionalType(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSTypeLiteral`], `None` otherwise.
    pub fn as_ts_type_literal(&self) -> Option<&TSTypeLiteral<'gc>> {
        if let Node::TSTypeLiteral(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSPropertySignature`], `None` otherwise.
    pub fn as_ts_property_signature(&self) -> Option<&TSPropertySignature<'gc>> {
        if let Node::TSPropertySignature(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSMethodSignature`], `None` otherwise.
    pub fn as_ts_method_signature(&self) -> Option<&TSMethodSignature<'gc>> {
        if let Node::TSMethodSignature(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSIndexSignature`], `None` otherwise.
    pub fn as_ts_index_signature(&self) -> Option<&TSIndexSignature<'gc>> {
        if let Node::TSIndexSignature(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSCallSignatureDeclaration`], `None`
    /// otherwise.
    pub fn as_ts_call_signature_declaration(&self) -> Option<&TSCallSignatureDeclaration<'gc>> {
        if let Node::TSCallSignatureDeclaration(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`TSModifiers`], `None` otherwise.
    pub fn as_ts_modifiers(&self) -> Option<&TSModifiers<'gc>> {
        if let Node::TSModifiers(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`CoverEmptyArgs`], `None` otherwise.
    pub fn as_cover_empty_args(&self) -> Option<&CoverEmptyArgs<'gc>> {
        if let Node::CoverEmptyArgs(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`CoverTrailingComma`], `None` otherwise.
    pub fn as_cover_trailing_comma(&self) -> Option<&CoverTrailingComma<'gc>> {
        if let Node::CoverTrailingComma(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`CoverInitializer`], `None` otherwise.
    pub fn as_cover_initializer(&self) -> Option<&CoverInitializer<'gc>> {
        if let Node::CoverInitializer(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`CoverRestElement`], `None` otherwise.
    pub fn as_cover_rest_element(&self) -> Option<&CoverRestElement<'gc>> {
        if let Node::CoverRestElement(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`CoverTypedIdentifier`], `None` otherwise.
    pub fn as_cover_typed_identifier(&self) -> Option<&CoverTypedIdentifier<'gc>> {
        if let Node::CoverTypedIdentifier(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`SHBuiltin`], `None` otherwise.
    pub fn as_sh_builtin(&self) -> Option<&SHBuiltin<'gc>> {
        if let Node::SHBuiltin(n) = self { Some(n) } else { None }
    }

    /// The payload if this is a [`ImplicitCheckedCast`], `None` otherwise.
    pub fn as_implicit_checked_cast(&self) -> Option<&ImplicitCheckedCast<'gc>> {
        if let Node::ImplicitCheckedCast(n) = self { Some(n) } else { None }
    }

    /// Visit every child node in declared order: the `ESTree.def`
    /// fields plus the decoration lists the GC marker must trace.
    pub fn visit_children<V: Visitor<'gc> + ?Sized>(&'gc self, v: &mut V) {
        match self {
            Node::Empty(_) => {}
            Node::Metadata(_) => {}
            Node::Program(n) => {
                for c in n.body.iter() { v.visit_node(c); }
                for c in n.decorations.get().iter() { v.visit_node(c); }
                for c in n.dummy_param_list.get().iter() { v.visit_node(c); }
            }
            Node::FunctionExpression(n) => {
                if let Some(c) = n.id { v.visit_node(c); }
                for c in n.params.iter() { v.visit_node(c); }
                v.visit_node(n.body);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.return_type { v.visit_node(c); }
                if let Some(c) = n.predicate { v.visit_node(c); }
                for c in n.decorations.get().iter() { v.visit_node(c); }
            }
            Node::ArrowFunctionExpression(n) => {
                for c in n.params.iter() { v.visit_node(c); }
                v.visit_node(n.body);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.return_type { v.visit_node(c); }
                if let Some(c) = n.predicate { v.visit_node(c); }
                for c in n.decorations.get().iter() { v.visit_node(c); }
            }
            Node::FunctionDeclaration(n) => {
                if let Some(c) = n.id { v.visit_node(c); }
                for c in n.params.iter() { v.visit_node(c); }
                v.visit_node(n.body);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.return_type { v.visit_node(c); }
                if let Some(c) = n.predicate { v.visit_node(c); }
                for c in n.decorations.get().iter() { v.visit_node(c); }
            }
            Node::ComponentDeclaration(n) => {
                v.visit_node(n.id);
                for c in n.params.iter() { v.visit_node(c); }
                v.visit_node(n.body);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.renders_type { v.visit_node(c); }
                for c in n.decorations.get().iter() { v.visit_node(c); }
            }
            Node::HookDeclaration(n) => {
                v.visit_node(n.id);
                for c in n.params.iter() { v.visit_node(c); }
                v.visit_node(n.body);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.return_type { v.visit_node(c); }
                for c in n.decorations.get().iter() { v.visit_node(c); }
            }
            Node::MatchStatement(n) => {
                v.visit_node(n.argument);
                for c in n.cases.iter() { v.visit_node(c); }
            }
            Node::WhileStatement(n) => {
                v.visit_node(n.body);
                v.visit_node(n.test);
            }
            Node::DoWhileStatement(n) => {
                v.visit_node(n.body);
                v.visit_node(n.test);
            }
            Node::ForInStatement(n) => {
                v.visit_node(n.left);
                v.visit_node(n.right);
                v.visit_node(n.body);
            }
            Node::ForOfStatement(n) => {
                v.visit_node(n.left);
                v.visit_node(n.right);
                v.visit_node(n.body);
            }
            Node::ForStatement(n) => {
                if let Some(c) = n.init { v.visit_node(c); }
                if let Some(c) = n.test { v.visit_node(c); }
                if let Some(c) = n.update { v.visit_node(c); }
                v.visit_node(n.body);
            }
            Node::DebuggerStatement(_) => {}
            Node::EmptyStatement(_) => {}
            Node::BlockStatement(n) => {
                for c in n.body.iter() { v.visit_node(c); }
            }
            Node::StaticBlock(n) => {
                for c in n.body.iter() { v.visit_node(c); }
            }
            Node::BreakStatement(n) => {
                if let Some(c) = n.label { v.visit_node(c); }
            }
            Node::ContinueStatement(n) => {
                if let Some(c) = n.label { v.visit_node(c); }
            }
            Node::ThrowStatement(n) => {
                v.visit_node(n.argument);
            }
            Node::ReturnStatement(n) => {
                if let Some(c) = n.argument { v.visit_node(c); }
            }
            Node::WithStatement(n) => {
                v.visit_node(n.object);
                v.visit_node(n.body);
            }
            Node::SwitchStatement(n) => {
                v.visit_node(n.discriminant);
                for c in n.cases.iter() { v.visit_node(c); }
            }
            Node::LabeledStatement(n) => {
                v.visit_node(n.label);
                v.visit_node(n.body);
            }
            Node::ExpressionStatement(n) => {
                v.visit_node(n.expression);
            }
            Node::TryStatement(n) => {
                v.visit_node(n.block);
                if let Some(c) = n.handler { v.visit_node(c); }
                if let Some(c) = n.finalizer { v.visit_node(c); }
            }
            Node::IfStatement(n) => {
                v.visit_node(n.test);
                v.visit_node(n.consequent);
                if let Some(c) = n.alternate { v.visit_node(c); }
            }
            Node::NullLiteral(_) => {}
            Node::BooleanLiteral(_) => {}
            Node::StringLiteral(_) => {}
            Node::NumericLiteral(_) => {}
            Node::RegExpLiteral(_) => {}
            Node::BigIntLiteral(_) => {}
            Node::ThisExpression(_) => {}
            Node::Super(_) => {}
            Node::SequenceExpression(n) => {
                for c in n.expressions.iter() { v.visit_node(c); }
            }
            Node::ObjectExpression(n) => {
                for c in n.properties.iter() { v.visit_node(c); }
            }
            Node::ArrayExpression(n) => {
                for c in n.elements.iter() { v.visit_node(c); }
            }
            Node::SpreadElement(n) => {
                v.visit_node(n.argument);
            }
            Node::NewExpression(n) => {
                v.visit_node(n.callee);
                if let Some(c) = n.type_arguments { v.visit_node(c); }
                for c in n.arguments.iter() { v.visit_node(c); }
            }
            Node::YieldExpression(n) => {
                if let Some(c) = n.argument { v.visit_node(c); }
            }
            Node::AwaitExpression(n) => {
                v.visit_node(n.argument);
            }
            Node::ImportExpression(n) => {
                v.visit_node(n.source);
                if let Some(c) = n.options { v.visit_node(c); }
            }
            Node::CallExpression(n) => {
                v.visit_node(n.callee);
                if let Some(c) = n.type_arguments { v.visit_node(c); }
                for c in n.arguments.iter() { v.visit_node(c); }
            }
            Node::OptionalCallExpression(n) => {
                v.visit_node(n.callee);
                if let Some(c) = n.type_arguments { v.visit_node(c); }
                for c in n.arguments.iter() { v.visit_node(c); }
            }
            Node::AssignmentExpression(n) => {
                v.visit_node(n.left);
                v.visit_node(n.right);
            }
            Node::UnaryExpression(n) => {
                v.visit_node(n.argument);
            }
            Node::UpdateExpression(n) => {
                v.visit_node(n.argument);
            }
            Node::MemberExpression(n) => {
                v.visit_node(n.object);
                v.visit_node(n.property);
            }
            Node::OptionalMemberExpression(n) => {
                v.visit_node(n.object);
                v.visit_node(n.property);
            }
            Node::LogicalExpression(n) => {
                v.visit_node(n.left);
                v.visit_node(n.right);
            }
            Node::ConditionalExpression(n) => {
                v.visit_node(n.test);
                v.visit_node(n.alternate);
                v.visit_node(n.consequent);
            }
            Node::BinaryExpression(n) => {
                v.visit_node(n.left);
                v.visit_node(n.right);
            }
            Node::Directive(n) => {
                v.visit_node(n.value);
            }
            Node::DirectiveLiteral(_) => {}
            Node::Identifier(n) => {
                if let Some(c) = n.type_annotation { v.visit_node(c); }
            }
            Node::PrivateName(n) => {
                v.visit_node(n.id);
            }
            Node::MetaProperty(n) => {
                v.visit_node(n.meta);
                v.visit_node(n.property);
            }
            Node::SwitchCase(n) => {
                if let Some(c) = n.test { v.visit_node(c); }
                for c in n.consequent.iter() { v.visit_node(c); }
            }
            Node::CatchClause(n) => {
                if let Some(c) = n.param { v.visit_node(c); }
                v.visit_node(n.body);
            }
            Node::VariableDeclarator(n) => {
                if let Some(c) = n.init { v.visit_node(c); }
                v.visit_node(n.id);
            }
            Node::VariableDeclaration(n) => {
                for c in n.declarations.iter() { v.visit_node(c); }
            }
            Node::TemplateLiteral(n) => {
                for c in n.quasis.iter() { v.visit_node(c); }
                for c in n.expressions.iter() { v.visit_node(c); }
            }
            Node::TaggedTemplateExpression(n) => {
                v.visit_node(n.tag);
                v.visit_node(n.quasi);
            }
            Node::TemplateElement(_) => {}
            Node::Property(n) => {
                v.visit_node(n.key);
                v.visit_node(n.value);
            }
            Node::Decorator(n) => {
                v.visit_node(n.expression);
            }
            Node::ClassDeclaration(n) => {
                if let Some(c) = n.id { v.visit_node(c); }
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.super_class { v.visit_node(c); }
                if let Some(c) = n.super_type_arguments { v.visit_node(c); }
                for c in n.implements.iter() { v.visit_node(c); }
                for c in n.decorators.iter() { v.visit_node(c); }
                v.visit_node(n.body);
            }
            Node::ClassExpression(n) => {
                if let Some(c) = n.id { v.visit_node(c); }
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.super_class { v.visit_node(c); }
                if let Some(c) = n.super_type_arguments { v.visit_node(c); }
                for c in n.implements.iter() { v.visit_node(c); }
                for c in n.decorators.iter() { v.visit_node(c); }
                v.visit_node(n.body);
            }
            Node::ClassBody(n) => {
                for c in n.body.iter() { v.visit_node(c); }
            }
            Node::ClassProperty(n) => {
                v.visit_node(n.key);
                if let Some(c) = n.value { v.visit_node(c); }
                for c in n.decorators.iter() { v.visit_node(c); }
                if let Some(c) = n.variance { v.visit_node(c); }
                if let Some(c) = n.type_annotation { v.visit_node(c); }
                if let Some(c) = n.ts_modifiers { v.visit_node(c); }
            }
            Node::ClassPrivateProperty(n) => {
                v.visit_node(n.key);
                if let Some(c) = n.value { v.visit_node(c); }
                for c in n.decorators.iter() { v.visit_node(c); }
                if let Some(c) = n.variance { v.visit_node(c); }
                if let Some(c) = n.type_annotation { v.visit_node(c); }
                if let Some(c) = n.ts_modifiers { v.visit_node(c); }
            }
            Node::MethodDefinition(n) => {
                v.visit_node(n.key);
                v.visit_node(n.value);
                for c in n.decorators.iter() { v.visit_node(c); }
            }
            Node::ImportDeclaration(n) => {
                for c in n.specifiers.iter() { v.visit_node(c); }
                v.visit_node(n.source);
                for c in n.attributes.iter() { v.visit_node(c); }
            }
            Node::ImportSpecifier(n) => {
                v.visit_node(n.imported);
                v.visit_node(n.local);
            }
            Node::ImportDefaultSpecifier(n) => {
                v.visit_node(n.local);
            }
            Node::ImportNamespaceSpecifier(n) => {
                v.visit_node(n.local);
            }
            Node::ImportAttribute(n) => {
                v.visit_node(n.key);
                v.visit_node(n.value);
            }
            Node::ExportNamedDeclaration(n) => {
                if let Some(c) = n.declaration { v.visit_node(c); }
                for c in n.specifiers.iter() { v.visit_node(c); }
                if let Some(c) = n.source { v.visit_node(c); }
            }
            Node::ExportSpecifier(n) => {
                v.visit_node(n.exported);
                v.visit_node(n.local);
            }
            Node::ExportNamespaceSpecifier(n) => {
                v.visit_node(n.exported);
            }
            Node::ExportDefaultDeclaration(n) => {
                v.visit_node(n.declaration);
            }
            Node::ExportAllDeclaration(n) => {
                v.visit_node(n.source);
            }
            Node::ObjectPattern(n) => {
                for c in n.properties.iter() { v.visit_node(c); }
                if let Some(c) = n.type_annotation { v.visit_node(c); }
            }
            Node::ArrayPattern(n) => {
                for c in n.elements.iter() { v.visit_node(c); }
                if let Some(c) = n.type_annotation { v.visit_node(c); }
            }
            Node::RestElement(n) => {
                v.visit_node(n.argument);
            }
            Node::AssignmentPattern(n) => {
                v.visit_node(n.left);
                v.visit_node(n.right);
            }
            Node::MatchStatementCase(n) => {
                v.visit_node(n.pattern);
                v.visit_node(n.body);
                if let Some(c) = n.guard { v.visit_node(c); }
            }
            Node::MatchExpression(n) => {
                v.visit_node(n.argument);
                for c in n.cases.iter() { v.visit_node(c); }
            }
            Node::MatchExpressionCase(n) => {
                v.visit_node(n.pattern);
                v.visit_node(n.body);
                if let Some(c) = n.guard { v.visit_node(c); }
            }
            Node::MatchWildcardPattern(_) => {}
            Node::MatchLiteralPattern(n) => {
                v.visit_node(n.literal);
            }
            Node::MatchUnaryPattern(n) => {
                v.visit_node(n.argument);
            }
            Node::MatchIdentifierPattern(n) => {
                v.visit_node(n.id);
            }
            Node::MatchBindingPattern(n) => {
                v.visit_node(n.id);
            }
            Node::MatchObjectPattern(n) => {
                for c in n.properties.iter() { v.visit_node(c); }
                if let Some(c) = n.rest { v.visit_node(c); }
            }
            Node::MatchArrayPattern(n) => {
                for c in n.elements.iter() { v.visit_node(c); }
                if let Some(c) = n.rest { v.visit_node(c); }
            }
            Node::MatchOrPattern(n) => {
                for c in n.patterns.iter() { v.visit_node(c); }
            }
            Node::MatchAsPattern(n) => {
                v.visit_node(n.pattern);
                v.visit_node(n.target);
            }
            Node::MatchMemberPattern(n) => {
                v.visit_node(n.base);
                v.visit_node(n.property);
            }
            Node::MatchInstancePattern(n) => {
                v.visit_node(n.target_constructor);
                v.visit_node(n.properties);
            }
            Node::MatchObjectPatternProperty(n) => {
                v.visit_node(n.key);
                v.visit_node(n.pattern);
            }
            Node::MatchInstanceObjectPattern(n) => {
                for c in n.properties.iter() { v.visit_node(c); }
                if let Some(c) = n.rest { v.visit_node(c); }
            }
            Node::MatchRestPattern(n) => {
                if let Some(c) = n.argument { v.visit_node(c); }
            }
            Node::JSXIdentifier(_) => {}
            Node::JSXMemberExpression(n) => {
                v.visit_node(n.object);
                v.visit_node(n.property);
            }
            Node::JSXNamespacedName(n) => {
                v.visit_node(n.namespace);
                v.visit_node(n.name);
            }
            Node::JSXEmptyExpression(_) => {}
            Node::JSXExpressionContainer(n) => {
                v.visit_node(n.expression);
            }
            Node::JSXSpreadChild(n) => {
                v.visit_node(n.expression);
            }
            Node::JSXOpeningElement(n) => {
                v.visit_node(n.name);
                for c in n.attributes.iter() { v.visit_node(c); }
                if let Some(c) = n.type_arguments { v.visit_node(c); }
            }
            Node::JSXClosingElement(n) => {
                v.visit_node(n.name);
            }
            Node::JSXAttribute(n) => {
                v.visit_node(n.name);
                if let Some(c) = n.value { v.visit_node(c); }
            }
            Node::JSXSpreadAttribute(n) => {
                v.visit_node(n.argument);
            }
            Node::JSXStringLiteral(_) => {}
            Node::JSXText(_) => {}
            Node::JSXElement(n) => {
                v.visit_node(n.opening_element);
                for c in n.children.iter() { v.visit_node(c); }
                if let Some(c) = n.closing_element { v.visit_node(c); }
            }
            Node::JSXFragment(n) => {
                v.visit_node(n.opening_fragment);
                for c in n.children.iter() { v.visit_node(c); }
                v.visit_node(n.closing_fragment);
            }
            Node::JSXOpeningFragment(_) => {}
            Node::JSXClosingFragment(_) => {}
            Node::ExistsTypeAnnotation(_) => {}
            Node::EmptyTypeAnnotation(_) => {}
            Node::StringTypeAnnotation(_) => {}
            Node::NumberTypeAnnotation(_) => {}
            Node::StringLiteralTypeAnnotation(_) => {}
            Node::NumberLiteralTypeAnnotation(_) => {}
            Node::BigIntLiteralTypeAnnotation(_) => {}
            Node::BooleanTypeAnnotation(_) => {}
            Node::BooleanLiteralTypeAnnotation(_) => {}
            Node::NullLiteralTypeAnnotation(_) => {}
            Node::SymbolTypeAnnotation(_) => {}
            Node::AnyTypeAnnotation(_) => {}
            Node::MixedTypeAnnotation(_) => {}
            Node::BigIntTypeAnnotation(_) => {}
            Node::VoidTypeAnnotation(_) => {}
            Node::NeverTypeAnnotation(_) => {}
            Node::UnknownTypeAnnotation(_) => {}
            Node::UndefinedTypeAnnotation(_) => {}
            Node::FunctionTypeAnnotation(n) => {
                for c in n.params.iter() { v.visit_node(c); }
                if let Some(c) = n.this { v.visit_node(c); }
                v.visit_node(n.return_type);
                if let Some(c) = n.rest { v.visit_node(c); }
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::HookTypeAnnotation(n) => {
                for c in n.params.iter() { v.visit_node(c); }
                v.visit_node(n.return_type);
                if let Some(c) = n.rest { v.visit_node(c); }
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::FunctionTypeParam(n) => {
                if let Some(c) = n.name { v.visit_node(c); }
                v.visit_node(n.type_annotation);
            }
            Node::ComponentTypeAnnotation(n) => {
                for c in n.params.iter() { v.visit_node(c); }
                if let Some(c) = n.rest { v.visit_node(c); }
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.renders_type { v.visit_node(c); }
            }
            Node::ComponentTypeParameter(n) => {
                if let Some(c) = n.name { v.visit_node(c); }
                v.visit_node(n.type_annotation);
            }
            Node::NullableTypeAnnotation(n) => {
                v.visit_node(n.type_annotation);
            }
            Node::QualifiedTypeIdentifier(n) => {
                v.visit_node(n.qualification);
                v.visit_node(n.id);
            }
            Node::TypeofTypeAnnotation(n) => {
                v.visit_node(n.argument);
                if let Some(c) = n.type_arguments { v.visit_node(c); }
            }
            Node::KeyofTypeAnnotation(n) => {
                v.visit_node(n.argument);
            }
            Node::TypeOperator(n) => {
                v.visit_node(n.type_annotation);
            }
            Node::QualifiedTypeofIdentifier(n) => {
                v.visit_node(n.qualification);
                v.visit_node(n.id);
            }
            Node::TupleTypeAnnotation(n) => {
                for c in n.element_types.iter() { v.visit_node(c); }
            }
            Node::TupleTypeSpreadElement(n) => {
                if let Some(c) = n.label { v.visit_node(c); }
                v.visit_node(n.type_annotation);
            }
            Node::TupleTypeLabeledElement(n) => {
                v.visit_node(n.label);
                v.visit_node(n.element_type);
                if let Some(c) = n.variance { v.visit_node(c); }
            }
            Node::ArrayTypeAnnotation(n) => {
                v.visit_node(n.element_type);
            }
            Node::InferTypeAnnotation(n) => {
                v.visit_node(n.type_parameter);
            }
            Node::UnionTypeAnnotation(n) => {
                for c in n.types.iter() { v.visit_node(c); }
            }
            Node::IntersectionTypeAnnotation(n) => {
                for c in n.types.iter() { v.visit_node(c); }
            }
            Node::GenericTypeAnnotation(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::IndexedAccessType(n) => {
                v.visit_node(n.object_type);
                v.visit_node(n.index_type);
            }
            Node::OptionalIndexedAccessType(n) => {
                v.visit_node(n.object_type);
                v.visit_node(n.index_type);
            }
            Node::ConditionalTypeAnnotation(n) => {
                v.visit_node(n.check_type);
                v.visit_node(n.extends_type);
                v.visit_node(n.true_type);
                v.visit_node(n.false_type);
            }
            Node::TypePredicate(n) => {
                v.visit_node(n.parameter_name);
                if let Some(c) = n.type_annotation { v.visit_node(c); }
            }
            Node::InterfaceTypeAnnotation(n) => {
                for c in n.extends.iter() { v.visit_node(c); }
                if let Some(c) = n.body { v.visit_node(c); }
            }
            Node::TypeAlias(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                v.visit_node(n.right);
            }
            Node::OpaqueType(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                v.visit_node(n.impltype);
                if let Some(c) = n.lower_bound { v.visit_node(c); }
                if let Some(c) = n.upper_bound { v.visit_node(c); }
                if let Some(c) = n.supertype { v.visit_node(c); }
            }
            Node::InterfaceDeclaration(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                for c in n.extends.iter() { v.visit_node(c); }
                v.visit_node(n.body);
            }
            Node::DeclareTypeAlias(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                v.visit_node(n.right);
            }
            Node::DeclareOpaqueType(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.impltype { v.visit_node(c); }
                if let Some(c) = n.lower_bound { v.visit_node(c); }
                if let Some(c) = n.upper_bound { v.visit_node(c); }
                if let Some(c) = n.supertype { v.visit_node(c); }
            }
            Node::DeclareInterface(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                for c in n.extends.iter() { v.visit_node(c); }
                v.visit_node(n.body);
            }
            Node::DeclareClass(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                for c in n.extends.iter() { v.visit_node(c); }
                for c in n.implements.iter() { v.visit_node(c); }
                for c in n.mixins.iter() { v.visit_node(c); }
                v.visit_node(n.body);
            }
            Node::DeclareFunction(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.predicate { v.visit_node(c); }
            }
            Node::DeclareHook(n) => {
                v.visit_node(n.id);
            }
            Node::DeclareComponent(n) => {
                v.visit_node(n.id);
                for c in n.params.iter() { v.visit_node(c); }
                if let Some(c) = n.rest { v.visit_node(c); }
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                if let Some(c) = n.renders_type { v.visit_node(c); }
            }
            Node::DeclareVariable(n) => {
                v.visit_node(n.id);
            }
            Node::DeclareEnum(n) => {
                v.visit_node(n.id);
                v.visit_node(n.body);
            }
            Node::DeclareExportDeclaration(n) => {
                if let Some(c) = n.declaration { v.visit_node(c); }
                for c in n.specifiers.iter() { v.visit_node(c); }
                if let Some(c) = n.source { v.visit_node(c); }
            }
            Node::DeclareExportAllDeclaration(n) => {
                v.visit_node(n.source);
            }
            Node::DeclareModule(n) => {
                v.visit_node(n.id);
                v.visit_node(n.body);
            }
            Node::DeclareNamespace(n) => {
                v.visit_node(n.id);
                v.visit_node(n.body);
            }
            Node::DeclareModuleExports(n) => {
                v.visit_node(n.type_annotation);
            }
            Node::InterfaceExtends(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::ClassImplements(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::TypeAnnotation(n) => {
                v.visit_node(n.type_annotation);
            }
            Node::ObjectTypeAnnotation(n) => {
                for c in n.properties.iter() { v.visit_node(c); }
                for c in n.indexers.iter() { v.visit_node(c); }
                for c in n.call_properties.iter() { v.visit_node(c); }
                for c in n.internal_slots.iter() { v.visit_node(c); }
            }
            Node::ObjectTypeProperty(n) => {
                v.visit_node(n.key);
                v.visit_node(n.value);
                if let Some(c) = n.variance { v.visit_node(c); }
            }
            Node::ObjectTypeSpreadProperty(n) => {
                v.visit_node(n.argument);
            }
            Node::ObjectTypeInternalSlot(n) => {
                v.visit_node(n.id);
                v.visit_node(n.value);
            }
            Node::ObjectTypeCallProperty(n) => {
                v.visit_node(n.value);
            }
            Node::ObjectTypeIndexer(n) => {
                if let Some(c) = n.id { v.visit_node(c); }
                v.visit_node(n.key);
                v.visit_node(n.value);
                if let Some(c) = n.variance { v.visit_node(c); }
            }
            Node::ObjectTypeMappedTypeProperty(n) => {
                v.visit_node(n.key_tparam);
                v.visit_node(n.prop_type);
                v.visit_node(n.source_type);
                if let Some(c) = n.variance { v.visit_node(c); }
            }
            Node::Variance(_) => {}
            Node::TypeParameterDeclaration(n) => {
                for c in n.params.iter() { v.visit_node(c); }
            }
            Node::TypeParameter(n) => {
                if let Some(c) = n.bound { v.visit_node(c); }
                if let Some(c) = n.variance { v.visit_node(c); }
                if let Some(c) = n.default { v.visit_node(c); }
            }
            Node::TypeParameterInstantiation(n) => {
                for c in n.params.iter() { v.visit_node(c); }
            }
            Node::TypeCastExpression(n) => {
                v.visit_node(n.expression);
                v.visit_node(n.type_annotation);
            }
            Node::AsExpression(n) => {
                v.visit_node(n.expression);
                v.visit_node(n.type_annotation);
            }
            Node::AsConstExpression(n) => {
                v.visit_node(n.expression);
            }
            Node::InferredPredicate(_) => {}
            Node::DeclaredPredicate(n) => {
                v.visit_node(n.value);
            }
            Node::EnumDeclaration(n) => {
                v.visit_node(n.id);
                v.visit_node(n.body);
            }
            Node::EnumStringBody(n) => {
                for c in n.members.iter() { v.visit_node(c); }
            }
            Node::EnumNumberBody(n) => {
                for c in n.members.iter() { v.visit_node(c); }
            }
            Node::EnumBigIntBody(n) => {
                for c in n.members.iter() { v.visit_node(c); }
            }
            Node::EnumBooleanBody(n) => {
                for c in n.members.iter() { v.visit_node(c); }
            }
            Node::EnumSymbolBody(n) => {
                for c in n.members.iter() { v.visit_node(c); }
            }
            Node::EnumDefaultedMember(n) => {
                v.visit_node(n.id);
            }
            Node::EnumStringMember(n) => {
                v.visit_node(n.id);
                v.visit_node(n.init);
            }
            Node::EnumNumberMember(n) => {
                v.visit_node(n.id);
                v.visit_node(n.init);
            }
            Node::EnumBigIntMember(n) => {
                v.visit_node(n.id);
                v.visit_node(n.init);
            }
            Node::EnumBooleanMember(n) => {
                v.visit_node(n.id);
                v.visit_node(n.init);
            }
            Node::ComponentParameter(n) => {
                v.visit_node(n.name);
                v.visit_node(n.local);
            }
            Node::RecordDeclaration(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                for c in n.implements.iter() { v.visit_node(c); }
                v.visit_node(n.body);
            }
            Node::RecordDeclarationImplements(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_arguments { v.visit_node(c); }
            }
            Node::RecordDeclarationBody(n) => {
                for c in n.elements.iter() { v.visit_node(c); }
            }
            Node::RecordDeclarationProperty(n) => {
                v.visit_node(n.key);
                v.visit_node(n.type_annotation);
                if let Some(c) = n.default_value { v.visit_node(c); }
            }
            Node::RecordDeclarationStaticProperty(n) => {
                v.visit_node(n.key);
                v.visit_node(n.type_annotation);
                v.visit_node(n.value);
            }
            Node::RecordExpression(n) => {
                v.visit_node(n.record_constructor);
                if let Some(c) = n.type_arguments { v.visit_node(c); }
                v.visit_node(n.properties);
            }
            Node::RecordExpressionProperties(n) => {
                for c in n.properties.iter() { v.visit_node(c); }
            }
            Node::TSTypeAnnotation(n) => {
                v.visit_node(n.type_annotation);
            }
            Node::TSAnyKeyword(_) => {}
            Node::TSNumberKeyword(_) => {}
            Node::TSBooleanKeyword(_) => {}
            Node::TSStringKeyword(_) => {}
            Node::TSSymbolKeyword(_) => {}
            Node::TSVoidKeyword(_) => {}
            Node::TSUndefinedKeyword(_) => {}
            Node::TSUnknownKeyword(_) => {}
            Node::TSNeverKeyword(_) => {}
            Node::TSBigIntKeyword(_) => {}
            Node::TSThisType(_) => {}
            Node::TSLiteralType(n) => {
                v.visit_node(n.literal);
            }
            Node::TSIndexedAccessType(n) => {
                v.visit_node(n.object_type);
                v.visit_node(n.index_type);
            }
            Node::TSArrayType(n) => {
                v.visit_node(n.element_type);
            }
            Node::TSTypeReference(n) => {
                v.visit_node(n.type_name);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::TSQualifiedName(n) => {
                v.visit_node(n.left);
                if let Some(c) = n.right { v.visit_node(c); }
            }
            Node::TSFunctionType(n) => {
                for c in n.params.iter() { v.visit_node(c); }
                v.visit_node(n.return_type);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::TSConstructorType(n) => {
                for c in n.params.iter() { v.visit_node(c); }
                v.visit_node(n.return_type);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::TSTypePredicate(n) => {
                v.visit_node(n.parameter_name);
                v.visit_node(n.type_annotation);
            }
            Node::TSTupleType(n) => {
                for c in n.element_types.iter() { v.visit_node(c); }
            }
            Node::TSTypeAssertion(n) => {
                v.visit_node(n.type_annotation);
                v.visit_node(n.expression);
            }
            Node::TSAsExpression(n) => {
                v.visit_node(n.expression);
                v.visit_node(n.type_annotation);
            }
            Node::TSParameterProperty(n) => {
                v.visit_node(n.parameter);
            }
            Node::TSTypeAliasDeclaration(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
                v.visit_node(n.type_annotation);
            }
            Node::TSInterfaceDeclaration(n) => {
                v.visit_node(n.id);
                v.visit_node(n.body);
                for c in n.extends.iter() { v.visit_node(c); }
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::TSInterfaceHeritage(n) => {
                v.visit_node(n.expression);
                if let Some(c) = n.type_parameters { v.visit_node(c); }
            }
            Node::TSInterfaceBody(n) => {
                for c in n.body.iter() { v.visit_node(c); }
            }
            Node::TSEnumDeclaration(n) => {
                v.visit_node(n.id);
                for c in n.members.iter() { v.visit_node(c); }
            }
            Node::TSEnumMember(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.initializer { v.visit_node(c); }
            }
            Node::TSModuleDeclaration(n) => {
                v.visit_node(n.id);
                v.visit_node(n.body);
            }
            Node::TSModuleBlock(n) => {
                for c in n.body.iter() { v.visit_node(c); }
            }
            Node::TSModuleMember(n) => {
                v.visit_node(n.id);
                if let Some(c) = n.initializer { v.visit_node(c); }
            }
            Node::TSTypeParameterDeclaration(n) => {
                for c in n.params.iter() { v.visit_node(c); }
            }
            Node::TSTypeParameter(n) => {
                v.visit_node(n.name);
                if let Some(c) = n.constraint { v.visit_node(c); }
                if let Some(c) = n.default { v.visit_node(c); }
            }
            Node::TSTypeParameterInstantiation(n) => {
                for c in n.params.iter() { v.visit_node(c); }
            }
            Node::TSUnionType(n) => {
                for c in n.types.iter() { v.visit_node(c); }
            }
            Node::TSIntersectionType(n) => {
                for c in n.types.iter() { v.visit_node(c); }
            }
            Node::TSTypeQuery(n) => {
                v.visit_node(n.expr_name);
            }
            Node::TSConditionalType(n) => {
                v.visit_node(n.check_type);
                v.visit_node(n.extends_type);
                v.visit_node(n.true_type);
                v.visit_node(n.false_type);
            }
            Node::TSTypeLiteral(n) => {
                for c in n.members.iter() { v.visit_node(c); }
            }
            Node::TSPropertySignature(n) => {
                v.visit_node(n.key);
                if let Some(c) = n.type_annotation { v.visit_node(c); }
                if let Some(c) = n.initializer { v.visit_node(c); }
            }
            Node::TSMethodSignature(n) => {
                v.visit_node(n.key);
                for c in n.params.iter() { v.visit_node(c); }
                if let Some(c) = n.return_type { v.visit_node(c); }
            }
            Node::TSIndexSignature(n) => {
                for c in n.parameters.iter() { v.visit_node(c); }
                if let Some(c) = n.type_annotation { v.visit_node(c); }
            }
            Node::TSCallSignatureDeclaration(n) => {
                for c in n.params.iter() { v.visit_node(c); }
                if let Some(c) = n.return_type { v.visit_node(c); }
            }
            Node::TSModifiers(_) => {}
            Node::CoverEmptyArgs(_) => {}
            Node::CoverTrailingComma(_) => {}
            Node::CoverInitializer(n) => {
                v.visit_node(n.init);
            }
            Node::CoverRestElement(n) => {
                v.visit_node(n.rest);
            }
            Node::CoverTypedIdentifier(n) => {
                v.visit_node(n.left);
                if let Some(c) = n.right { v.visit_node(c); }
            }
            Node::SHBuiltin(_) => {}
            Node::ImplicitCheckedCast(n) => {
                v.visit_node(n.argument);
            }
        }
    }

    /// Transform this node's children with `visitor`, rebuilding it only if
    /// a child changed. `self` is the original parent.
    pub fn visit_children_mut<V: VisitorMut<'gc>>(
        &'gc self,
        ctx: &'gc crate::context::GCLock<'_, '_>,
        visitor: &mut V,
    ) -> TransformResult<&'gc Node<'gc>> {
        let builder = builder::Builder::from_node(self);
        #[allow(unused_mut)]
        match builder {
            builder::Builder::Empty(mut b) => b.build(ctx),
            builder::Builder::Metadata(mut b) => b.build(ctx),
            builder::Builder::Program(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::FunctionExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.predicate.visit_child_mut(ctx, visitor, Path::new(self, NodeField::predicate)) {
                    b.predicate(v);
                }
                b.build(ctx)
            }
            builder::Builder::ArrowFunctionExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.predicate.visit_child_mut(ctx, visitor, Path::new(self, NodeField::predicate)) {
                    b.predicate(v);
                }
                b.build(ctx)
            }
            builder::Builder::FunctionDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.predicate.visit_child_mut(ctx, visitor, Path::new(self, NodeField::predicate)) {
                    b.predicate(v);
                }
                b.build(ctx)
            }
            builder::Builder::ComponentDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.renders_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::renders_type)) {
                    b.renders_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::HookDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.cases.visit_child_mut(ctx, visitor, Path::new(self, NodeField::cases)) {
                    b.cases(v);
                }
                b.build(ctx)
            }
            builder::Builder::WhileStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.test.visit_child_mut(ctx, visitor, Path::new(self, NodeField::test)) {
                    b.test(v);
                }
                b.build(ctx)
            }
            builder::Builder::DoWhileStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.test.visit_child_mut(ctx, visitor, Path::new(self, NodeField::test)) {
                    b.test(v);
                }
                b.build(ctx)
            }
            builder::Builder::ForInStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.left.visit_child_mut(ctx, visitor, Path::new(self, NodeField::left)) {
                    b.left(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::ForOfStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.left.visit_child_mut(ctx, visitor, Path::new(self, NodeField::left)) {
                    b.left(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::ForStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.init.visit_child_mut(ctx, visitor, Path::new(self, NodeField::init)) {
                    b.init(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.test.visit_child_mut(ctx, visitor, Path::new(self, NodeField::test)) {
                    b.test(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.update.visit_child_mut(ctx, visitor, Path::new(self, NodeField::update)) {
                    b.update(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::DebuggerStatement(mut b) => b.build(ctx),
            builder::Builder::EmptyStatement(mut b) => b.build(ctx),
            builder::Builder::BlockStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::StaticBlock(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::BreakStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.label.visit_child_mut(ctx, visitor, Path::new(self, NodeField::label)) {
                    b.label(v);
                }
                b.build(ctx)
            }
            builder::Builder::ContinueStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.label.visit_child_mut(ctx, visitor, Path::new(self, NodeField::label)) {
                    b.label(v);
                }
                b.build(ctx)
            }
            builder::Builder::ThrowStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::ReturnStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::WithStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.object.visit_child_mut(ctx, visitor, Path::new(self, NodeField::object)) {
                    b.object(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::SwitchStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.discriminant.visit_child_mut(ctx, visitor, Path::new(self, NodeField::discriminant)) {
                    b.discriminant(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.cases.visit_child_mut(ctx, visitor, Path::new(self, NodeField::cases)) {
                    b.cases(v);
                }
                b.build(ctx)
            }
            builder::Builder::LabeledStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.label.visit_child_mut(ctx, visitor, Path::new(self, NodeField::label)) {
                    b.label(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::ExpressionStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                b.build(ctx)
            }
            builder::Builder::TryStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.block.visit_child_mut(ctx, visitor, Path::new(self, NodeField::block)) {
                    b.block(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.handler.visit_child_mut(ctx, visitor, Path::new(self, NodeField::handler)) {
                    b.handler(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.finalizer.visit_child_mut(ctx, visitor, Path::new(self, NodeField::finalizer)) {
                    b.finalizer(v);
                }
                b.build(ctx)
            }
            builder::Builder::IfStatement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.test.visit_child_mut(ctx, visitor, Path::new(self, NodeField::test)) {
                    b.test(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.consequent.visit_child_mut(ctx, visitor, Path::new(self, NodeField::consequent)) {
                    b.consequent(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.alternate.visit_child_mut(ctx, visitor, Path::new(self, NodeField::alternate)) {
                    b.alternate(v);
                }
                b.build(ctx)
            }
            builder::Builder::NullLiteral(mut b) => b.build(ctx),
            builder::Builder::BooleanLiteral(mut b) => b.build(ctx),
            builder::Builder::StringLiteral(mut b) => b.build(ctx),
            builder::Builder::NumericLiteral(mut b) => b.build(ctx),
            builder::Builder::RegExpLiteral(mut b) => b.build(ctx),
            builder::Builder::BigIntLiteral(mut b) => b.build(ctx),
            builder::Builder::ThisExpression(mut b) => b.build(ctx),
            builder::Builder::Super(mut b) => b.build(ctx),
            builder::Builder::SequenceExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expressions.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expressions)) {
                    b.expressions(v);
                }
                b.build(ctx)
            }
            builder::Builder::ObjectExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.properties.visit_child_mut(ctx, visitor, Path::new(self, NodeField::properties)) {
                    b.properties(v);
                }
                b.build(ctx)
            }
            builder::Builder::ArrayExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.elements.visit_child_mut(ctx, visitor, Path::new(self, NodeField::elements)) {
                    b.elements(v);
                }
                b.build(ctx)
            }
            builder::Builder::SpreadElement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::NewExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.callee.visit_child_mut(ctx, visitor, Path::new(self, NodeField::callee)) {
                    b.callee(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_arguments)) {
                    b.type_arguments(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::arguments)) {
                    b.arguments(v);
                }
                b.build(ctx)
            }
            builder::Builder::YieldExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::AwaitExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::ImportExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.source.visit_child_mut(ctx, visitor, Path::new(self, NodeField::source)) {
                    b.source(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.options.visit_child_mut(ctx, visitor, Path::new(self, NodeField::options)) {
                    b.options(v);
                }
                b.build(ctx)
            }
            builder::Builder::CallExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.callee.visit_child_mut(ctx, visitor, Path::new(self, NodeField::callee)) {
                    b.callee(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_arguments)) {
                    b.type_arguments(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::arguments)) {
                    b.arguments(v);
                }
                b.build(ctx)
            }
            builder::Builder::OptionalCallExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.callee.visit_child_mut(ctx, visitor, Path::new(self, NodeField::callee)) {
                    b.callee(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_arguments)) {
                    b.type_arguments(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::arguments)) {
                    b.arguments(v);
                }
                b.build(ctx)
            }
            builder::Builder::AssignmentExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.left.visit_child_mut(ctx, visitor, Path::new(self, NodeField::left)) {
                    b.left(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                b.build(ctx)
            }
            builder::Builder::UnaryExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::UpdateExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::MemberExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.object.visit_child_mut(ctx, visitor, Path::new(self, NodeField::object)) {
                    b.object(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.property.visit_child_mut(ctx, visitor, Path::new(self, NodeField::property)) {
                    b.property(v);
                }
                b.build(ctx)
            }
            builder::Builder::OptionalMemberExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.object.visit_child_mut(ctx, visitor, Path::new(self, NodeField::object)) {
                    b.object(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.property.visit_child_mut(ctx, visitor, Path::new(self, NodeField::property)) {
                    b.property(v);
                }
                b.build(ctx)
            }
            builder::Builder::LogicalExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.left.visit_child_mut(ctx, visitor, Path::new(self, NodeField::left)) {
                    b.left(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                b.build(ctx)
            }
            builder::Builder::ConditionalExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.test.visit_child_mut(ctx, visitor, Path::new(self, NodeField::test)) {
                    b.test(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.alternate.visit_child_mut(ctx, visitor, Path::new(self, NodeField::alternate)) {
                    b.alternate(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.consequent.visit_child_mut(ctx, visitor, Path::new(self, NodeField::consequent)) {
                    b.consequent(v);
                }
                b.build(ctx)
            }
            builder::Builder::BinaryExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.left.visit_child_mut(ctx, visitor, Path::new(self, NodeField::left)) {
                    b.left(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                b.build(ctx)
            }
            builder::Builder::Directive(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                b.build(ctx)
            }
            builder::Builder::DirectiveLiteral(mut b) => b.build(ctx),
            builder::Builder::Identifier(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::PrivateName(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                b.build(ctx)
            }
            builder::Builder::MetaProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.meta.visit_child_mut(ctx, visitor, Path::new(self, NodeField::meta)) {
                    b.meta(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.property.visit_child_mut(ctx, visitor, Path::new(self, NodeField::property)) {
                    b.property(v);
                }
                b.build(ctx)
            }
            builder::Builder::SwitchCase(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.test.visit_child_mut(ctx, visitor, Path::new(self, NodeField::test)) {
                    b.test(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.consequent.visit_child_mut(ctx, visitor, Path::new(self, NodeField::consequent)) {
                    b.consequent(v);
                }
                b.build(ctx)
            }
            builder::Builder::CatchClause(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.param.visit_child_mut(ctx, visitor, Path::new(self, NodeField::param)) {
                    b.param(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::VariableDeclarator(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.init.visit_child_mut(ctx, visitor, Path::new(self, NodeField::init)) {
                    b.init(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                b.build(ctx)
            }
            builder::Builder::VariableDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.declarations.visit_child_mut(ctx, visitor, Path::new(self, NodeField::declarations)) {
                    b.declarations(v);
                }
                b.build(ctx)
            }
            builder::Builder::TemplateLiteral(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.quasis.visit_child_mut(ctx, visitor, Path::new(self, NodeField::quasis)) {
                    b.quasis(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.expressions.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expressions)) {
                    b.expressions(v);
                }
                b.build(ctx)
            }
            builder::Builder::TaggedTemplateExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.tag.visit_child_mut(ctx, visitor, Path::new(self, NodeField::tag)) {
                    b.tag(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.quasi.visit_child_mut(ctx, visitor, Path::new(self, NodeField::quasi)) {
                    b.quasi(v);
                }
                b.build(ctx)
            }
            builder::Builder::TemplateElement(mut b) => b.build(ctx),
            builder::Builder::Property(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                b.build(ctx)
            }
            builder::Builder::Decorator(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                b.build(ctx)
            }
            builder::Builder::ClassDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.super_class.visit_child_mut(ctx, visitor, Path::new(self, NodeField::super_class)) {
                    b.super_class(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.super_type_arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::super_type_arguments)) {
                    b.super_type_arguments(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.implements.visit_child_mut(ctx, visitor, Path::new(self, NodeField::implements)) {
                    b.implements(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.decorators.visit_child_mut(ctx, visitor, Path::new(self, NodeField::decorators)) {
                    b.decorators(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::ClassExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.super_class.visit_child_mut(ctx, visitor, Path::new(self, NodeField::super_class)) {
                    b.super_class(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.super_type_arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::super_type_arguments)) {
                    b.super_type_arguments(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.implements.visit_child_mut(ctx, visitor, Path::new(self, NodeField::implements)) {
                    b.implements(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.decorators.visit_child_mut(ctx, visitor, Path::new(self, NodeField::decorators)) {
                    b.decorators(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::ClassBody(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::ClassProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.decorators.visit_child_mut(ctx, visitor, Path::new(self, NodeField::decorators)) {
                    b.decorators(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.variance.visit_child_mut(ctx, visitor, Path::new(self, NodeField::variance)) {
                    b.variance(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.ts_modifiers.visit_child_mut(ctx, visitor, Path::new(self, NodeField::ts_modifiers)) {
                    b.ts_modifiers(v);
                }
                b.build(ctx)
            }
            builder::Builder::ClassPrivateProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.decorators.visit_child_mut(ctx, visitor, Path::new(self, NodeField::decorators)) {
                    b.decorators(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.variance.visit_child_mut(ctx, visitor, Path::new(self, NodeField::variance)) {
                    b.variance(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.ts_modifiers.visit_child_mut(ctx, visitor, Path::new(self, NodeField::ts_modifiers)) {
                    b.ts_modifiers(v);
                }
                b.build(ctx)
            }
            builder::Builder::MethodDefinition(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.decorators.visit_child_mut(ctx, visitor, Path::new(self, NodeField::decorators)) {
                    b.decorators(v);
                }
                b.build(ctx)
            }
            builder::Builder::ImportDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.specifiers.visit_child_mut(ctx, visitor, Path::new(self, NodeField::specifiers)) {
                    b.specifiers(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.source.visit_child_mut(ctx, visitor, Path::new(self, NodeField::source)) {
                    b.source(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.attributes.visit_child_mut(ctx, visitor, Path::new(self, NodeField::attributes)) {
                    b.attributes(v);
                }
                b.build(ctx)
            }
            builder::Builder::ImportSpecifier(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.imported.visit_child_mut(ctx, visitor, Path::new(self, NodeField::imported)) {
                    b.imported(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.local.visit_child_mut(ctx, visitor, Path::new(self, NodeField::local)) {
                    b.local(v);
                }
                b.build(ctx)
            }
            builder::Builder::ImportDefaultSpecifier(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.local.visit_child_mut(ctx, visitor, Path::new(self, NodeField::local)) {
                    b.local(v);
                }
                b.build(ctx)
            }
            builder::Builder::ImportNamespaceSpecifier(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.local.visit_child_mut(ctx, visitor, Path::new(self, NodeField::local)) {
                    b.local(v);
                }
                b.build(ctx)
            }
            builder::Builder::ImportAttribute(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                b.build(ctx)
            }
            builder::Builder::ExportNamedDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.declaration.visit_child_mut(ctx, visitor, Path::new(self, NodeField::declaration)) {
                    b.declaration(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.specifiers.visit_child_mut(ctx, visitor, Path::new(self, NodeField::specifiers)) {
                    b.specifiers(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.source.visit_child_mut(ctx, visitor, Path::new(self, NodeField::source)) {
                    b.source(v);
                }
                b.build(ctx)
            }
            builder::Builder::ExportSpecifier(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.exported.visit_child_mut(ctx, visitor, Path::new(self, NodeField::exported)) {
                    b.exported(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.local.visit_child_mut(ctx, visitor, Path::new(self, NodeField::local)) {
                    b.local(v);
                }
                b.build(ctx)
            }
            builder::Builder::ExportNamespaceSpecifier(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.exported.visit_child_mut(ctx, visitor, Path::new(self, NodeField::exported)) {
                    b.exported(v);
                }
                b.build(ctx)
            }
            builder::Builder::ExportDefaultDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.declaration.visit_child_mut(ctx, visitor, Path::new(self, NodeField::declaration)) {
                    b.declaration(v);
                }
                b.build(ctx)
            }
            builder::Builder::ExportAllDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.source.visit_child_mut(ctx, visitor, Path::new(self, NodeField::source)) {
                    b.source(v);
                }
                b.build(ctx)
            }
            builder::Builder::ObjectPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.properties.visit_child_mut(ctx, visitor, Path::new(self, NodeField::properties)) {
                    b.properties(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::ArrayPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.elements.visit_child_mut(ctx, visitor, Path::new(self, NodeField::elements)) {
                    b.elements(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::RestElement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::AssignmentPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.left.visit_child_mut(ctx, visitor, Path::new(self, NodeField::left)) {
                    b.left(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchStatementCase(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.pattern.visit_child_mut(ctx, visitor, Path::new(self, NodeField::pattern)) {
                    b.pattern(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.guard.visit_child_mut(ctx, visitor, Path::new(self, NodeField::guard)) {
                    b.guard(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.cases.visit_child_mut(ctx, visitor, Path::new(self, NodeField::cases)) {
                    b.cases(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchExpressionCase(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.pattern.visit_child_mut(ctx, visitor, Path::new(self, NodeField::pattern)) {
                    b.pattern(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.guard.visit_child_mut(ctx, visitor, Path::new(self, NodeField::guard)) {
                    b.guard(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchWildcardPattern(mut b) => b.build(ctx),
            builder::Builder::MatchLiteralPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.literal.visit_child_mut(ctx, visitor, Path::new(self, NodeField::literal)) {
                    b.literal(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchUnaryPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchIdentifierPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchBindingPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchObjectPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.properties.visit_child_mut(ctx, visitor, Path::new(self, NodeField::properties)) {
                    b.properties(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.rest.visit_child_mut(ctx, visitor, Path::new(self, NodeField::rest)) {
                    b.rest(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchArrayPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.elements.visit_child_mut(ctx, visitor, Path::new(self, NodeField::elements)) {
                    b.elements(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.rest.visit_child_mut(ctx, visitor, Path::new(self, NodeField::rest)) {
                    b.rest(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchOrPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.patterns.visit_child_mut(ctx, visitor, Path::new(self, NodeField::patterns)) {
                    b.patterns(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchAsPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.pattern.visit_child_mut(ctx, visitor, Path::new(self, NodeField::pattern)) {
                    b.pattern(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.target.visit_child_mut(ctx, visitor, Path::new(self, NodeField::target)) {
                    b.target(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchMemberPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.base.visit_child_mut(ctx, visitor, Path::new(self, NodeField::base)) {
                    b.base(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.property.visit_child_mut(ctx, visitor, Path::new(self, NodeField::property)) {
                    b.property(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchInstancePattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.target_constructor.visit_child_mut(ctx, visitor, Path::new(self, NodeField::target_constructor)) {
                    b.target_constructor(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.properties.visit_child_mut(ctx, visitor, Path::new(self, NodeField::properties)) {
                    b.properties(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchObjectPatternProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.pattern.visit_child_mut(ctx, visitor, Path::new(self, NodeField::pattern)) {
                    b.pattern(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchInstanceObjectPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.properties.visit_child_mut(ctx, visitor, Path::new(self, NodeField::properties)) {
                    b.properties(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.rest.visit_child_mut(ctx, visitor, Path::new(self, NodeField::rest)) {
                    b.rest(v);
                }
                b.build(ctx)
            }
            builder::Builder::MatchRestPattern(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXIdentifier(mut b) => b.build(ctx),
            builder::Builder::JSXMemberExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.object.visit_child_mut(ctx, visitor, Path::new(self, NodeField::object)) {
                    b.object(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.property.visit_child_mut(ctx, visitor, Path::new(self, NodeField::property)) {
                    b.property(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXNamespacedName(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.namespace.visit_child_mut(ctx, visitor, Path::new(self, NodeField::namespace)) {
                    b.namespace(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::name)) {
                    b.name(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXEmptyExpression(mut b) => b.build(ctx),
            builder::Builder::JSXExpressionContainer(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXSpreadChild(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXOpeningElement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::name)) {
                    b.name(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.attributes.visit_child_mut(ctx, visitor, Path::new(self, NodeField::attributes)) {
                    b.attributes(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_arguments)) {
                    b.type_arguments(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXClosingElement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::name)) {
                    b.name(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXAttribute(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::name)) {
                    b.name(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXSpreadAttribute(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXStringLiteral(mut b) => b.build(ctx),
            builder::Builder::JSXText(mut b) => b.build(ctx),
            builder::Builder::JSXElement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.opening_element.visit_child_mut(ctx, visitor, Path::new(self, NodeField::opening_element)) {
                    b.opening_element(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.children.visit_child_mut(ctx, visitor, Path::new(self, NodeField::children)) {
                    b.children(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.closing_element.visit_child_mut(ctx, visitor, Path::new(self, NodeField::closing_element)) {
                    b.closing_element(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXFragment(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.opening_fragment.visit_child_mut(ctx, visitor, Path::new(self, NodeField::opening_fragment)) {
                    b.opening_fragment(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.children.visit_child_mut(ctx, visitor, Path::new(self, NodeField::children)) {
                    b.children(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.closing_fragment.visit_child_mut(ctx, visitor, Path::new(self, NodeField::closing_fragment)) {
                    b.closing_fragment(v);
                }
                b.build(ctx)
            }
            builder::Builder::JSXOpeningFragment(mut b) => b.build(ctx),
            builder::Builder::JSXClosingFragment(mut b) => b.build(ctx),
            builder::Builder::ExistsTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::EmptyTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::StringTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::NumberTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::StringLiteralTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::NumberLiteralTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::BigIntLiteralTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::BooleanTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::BooleanLiteralTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::NullLiteralTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::SymbolTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::AnyTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::MixedTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::BigIntTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::VoidTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::NeverTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::UnknownTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::UndefinedTypeAnnotation(mut b) => b.build(ctx),
            builder::Builder::FunctionTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.this.visit_child_mut(ctx, visitor, Path::new(self, NodeField::this)) {
                    b.this(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.rest.visit_child_mut(ctx, visitor, Path::new(self, NodeField::rest)) {
                    b.rest(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::HookTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.rest.visit_child_mut(ctx, visitor, Path::new(self, NodeField::rest)) {
                    b.rest(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::FunctionTypeParam(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::name)) {
                    b.name(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::ComponentTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.rest.visit_child_mut(ctx, visitor, Path::new(self, NodeField::rest)) {
                    b.rest(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.renders_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::renders_type)) {
                    b.renders_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::ComponentTypeParameter(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::name)) {
                    b.name(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::NullableTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::QualifiedTypeIdentifier(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.qualification.visit_child_mut(ctx, visitor, Path::new(self, NodeField::qualification)) {
                    b.qualification(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                b.build(ctx)
            }
            builder::Builder::TypeofTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_arguments)) {
                    b.type_arguments(v);
                }
                b.build(ctx)
            }
            builder::Builder::KeyofTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::TypeOperator(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::QualifiedTypeofIdentifier(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.qualification.visit_child_mut(ctx, visitor, Path::new(self, NodeField::qualification)) {
                    b.qualification(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                b.build(ctx)
            }
            builder::Builder::TupleTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.element_types.visit_child_mut(ctx, visitor, Path::new(self, NodeField::element_types)) {
                    b.element_types(v);
                }
                b.build(ctx)
            }
            builder::Builder::TupleTypeSpreadElement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.label.visit_child_mut(ctx, visitor, Path::new(self, NodeField::label)) {
                    b.label(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::TupleTypeLabeledElement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.label.visit_child_mut(ctx, visitor, Path::new(self, NodeField::label)) {
                    b.label(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.element_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::element_type)) {
                    b.element_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.variance.visit_child_mut(ctx, visitor, Path::new(self, NodeField::variance)) {
                    b.variance(v);
                }
                b.build(ctx)
            }
            builder::Builder::ArrayTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.element_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::element_type)) {
                    b.element_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::InferTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.type_parameter.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameter)) {
                    b.type_parameter(v);
                }
                b.build(ctx)
            }
            builder::Builder::UnionTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.types.visit_child_mut(ctx, visitor, Path::new(self, NodeField::types)) {
                    b.types(v);
                }
                b.build(ctx)
            }
            builder::Builder::IntersectionTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.types.visit_child_mut(ctx, visitor, Path::new(self, NodeField::types)) {
                    b.types(v);
                }
                b.build(ctx)
            }
            builder::Builder::GenericTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::IndexedAccessType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.object_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::object_type)) {
                    b.object_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.index_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::index_type)) {
                    b.index_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::OptionalIndexedAccessType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.object_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::object_type)) {
                    b.object_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.index_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::index_type)) {
                    b.index_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::ConditionalTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.check_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::check_type)) {
                    b.check_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.extends_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::extends_type)) {
                    b.extends_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.true_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::true_type)) {
                    b.true_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.false_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::false_type)) {
                    b.false_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::TypePredicate(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.parameter_name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::parameter_name)) {
                    b.parameter_name(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::InterfaceTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.extends.visit_child_mut(ctx, visitor, Path::new(self, NodeField::extends)) {
                    b.extends(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::TypeAlias(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                b.build(ctx)
            }
            builder::Builder::OpaqueType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.impltype.visit_child_mut(ctx, visitor, Path::new(self, NodeField::impltype)) {
                    b.impltype(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.lower_bound.visit_child_mut(ctx, visitor, Path::new(self, NodeField::lower_bound)) {
                    b.lower_bound(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.upper_bound.visit_child_mut(ctx, visitor, Path::new(self, NodeField::upper_bound)) {
                    b.upper_bound(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.supertype.visit_child_mut(ctx, visitor, Path::new(self, NodeField::supertype)) {
                    b.supertype(v);
                }
                b.build(ctx)
            }
            builder::Builder::InterfaceDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.extends.visit_child_mut(ctx, visitor, Path::new(self, NodeField::extends)) {
                    b.extends(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareTypeAlias(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareOpaqueType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.impltype.visit_child_mut(ctx, visitor, Path::new(self, NodeField::impltype)) {
                    b.impltype(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.lower_bound.visit_child_mut(ctx, visitor, Path::new(self, NodeField::lower_bound)) {
                    b.lower_bound(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.upper_bound.visit_child_mut(ctx, visitor, Path::new(self, NodeField::upper_bound)) {
                    b.upper_bound(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.supertype.visit_child_mut(ctx, visitor, Path::new(self, NodeField::supertype)) {
                    b.supertype(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareInterface(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.extends.visit_child_mut(ctx, visitor, Path::new(self, NodeField::extends)) {
                    b.extends(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareClass(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.extends.visit_child_mut(ctx, visitor, Path::new(self, NodeField::extends)) {
                    b.extends(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.implements.visit_child_mut(ctx, visitor, Path::new(self, NodeField::implements)) {
                    b.implements(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.mixins.visit_child_mut(ctx, visitor, Path::new(self, NodeField::mixins)) {
                    b.mixins(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareFunction(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.predicate.visit_child_mut(ctx, visitor, Path::new(self, NodeField::predicate)) {
                    b.predicate(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareHook(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareComponent(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.rest.visit_child_mut(ctx, visitor, Path::new(self, NodeField::rest)) {
                    b.rest(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.renders_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::renders_type)) {
                    b.renders_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareVariable(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareEnum(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareExportDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.declaration.visit_child_mut(ctx, visitor, Path::new(self, NodeField::declaration)) {
                    b.declaration(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.specifiers.visit_child_mut(ctx, visitor, Path::new(self, NodeField::specifiers)) {
                    b.specifiers(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.source.visit_child_mut(ctx, visitor, Path::new(self, NodeField::source)) {
                    b.source(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareExportAllDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.source.visit_child_mut(ctx, visitor, Path::new(self, NodeField::source)) {
                    b.source(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareModule(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareNamespace(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::DeclareModuleExports(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::InterfaceExtends(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::ClassImplements(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::TypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::ObjectTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.properties.visit_child_mut(ctx, visitor, Path::new(self, NodeField::properties)) {
                    b.properties(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.indexers.visit_child_mut(ctx, visitor, Path::new(self, NodeField::indexers)) {
                    b.indexers(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.call_properties.visit_child_mut(ctx, visitor, Path::new(self, NodeField::call_properties)) {
                    b.call_properties(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.internal_slots.visit_child_mut(ctx, visitor, Path::new(self, NodeField::internal_slots)) {
                    b.internal_slots(v);
                }
                b.build(ctx)
            }
            builder::Builder::ObjectTypeProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.variance.visit_child_mut(ctx, visitor, Path::new(self, NodeField::variance)) {
                    b.variance(v);
                }
                b.build(ctx)
            }
            builder::Builder::ObjectTypeSpreadProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
            builder::Builder::ObjectTypeInternalSlot(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                b.build(ctx)
            }
            builder::Builder::ObjectTypeCallProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                b.build(ctx)
            }
            builder::Builder::ObjectTypeIndexer(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.variance.visit_child_mut(ctx, visitor, Path::new(self, NodeField::variance)) {
                    b.variance(v);
                }
                b.build(ctx)
            }
            builder::Builder::ObjectTypeMappedTypeProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key_tparam.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key_tparam)) {
                    b.key_tparam(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.prop_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::prop_type)) {
                    b.prop_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.source_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::source_type)) {
                    b.source_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.variance.visit_child_mut(ctx, visitor, Path::new(self, NodeField::variance)) {
                    b.variance(v);
                }
                b.build(ctx)
            }
            builder::Builder::Variance(mut b) => b.build(ctx),
            builder::Builder::TypeParameterDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                b.build(ctx)
            }
            builder::Builder::TypeParameter(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.bound.visit_child_mut(ctx, visitor, Path::new(self, NodeField::bound)) {
                    b.bound(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.variance.visit_child_mut(ctx, visitor, Path::new(self, NodeField::variance)) {
                    b.variance(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.default.visit_child_mut(ctx, visitor, Path::new(self, NodeField::default)) {
                    b.default(v);
                }
                b.build(ctx)
            }
            builder::Builder::TypeParameterInstantiation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                b.build(ctx)
            }
            builder::Builder::TypeCastExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::AsExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::AsConstExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                b.build(ctx)
            }
            builder::Builder::InferredPredicate(mut b) => b.build(ctx),
            builder::Builder::DeclaredPredicate(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumStringBody(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.members.visit_child_mut(ctx, visitor, Path::new(self, NodeField::members)) {
                    b.members(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumNumberBody(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.members.visit_child_mut(ctx, visitor, Path::new(self, NodeField::members)) {
                    b.members(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumBigIntBody(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.members.visit_child_mut(ctx, visitor, Path::new(self, NodeField::members)) {
                    b.members(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumBooleanBody(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.members.visit_child_mut(ctx, visitor, Path::new(self, NodeField::members)) {
                    b.members(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumSymbolBody(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.members.visit_child_mut(ctx, visitor, Path::new(self, NodeField::members)) {
                    b.members(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumDefaultedMember(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumStringMember(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.init.visit_child_mut(ctx, visitor, Path::new(self, NodeField::init)) {
                    b.init(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumNumberMember(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.init.visit_child_mut(ctx, visitor, Path::new(self, NodeField::init)) {
                    b.init(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumBigIntMember(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.init.visit_child_mut(ctx, visitor, Path::new(self, NodeField::init)) {
                    b.init(v);
                }
                b.build(ctx)
            }
            builder::Builder::EnumBooleanMember(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.init.visit_child_mut(ctx, visitor, Path::new(self, NodeField::init)) {
                    b.init(v);
                }
                b.build(ctx)
            }
            builder::Builder::ComponentParameter(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::name)) {
                    b.name(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.local.visit_child_mut(ctx, visitor, Path::new(self, NodeField::local)) {
                    b.local(v);
                }
                b.build(ctx)
            }
            builder::Builder::RecordDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.implements.visit_child_mut(ctx, visitor, Path::new(self, NodeField::implements)) {
                    b.implements(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::RecordDeclarationImplements(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_arguments)) {
                    b.type_arguments(v);
                }
                b.build(ctx)
            }
            builder::Builder::RecordDeclarationBody(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.elements.visit_child_mut(ctx, visitor, Path::new(self, NodeField::elements)) {
                    b.elements(v);
                }
                b.build(ctx)
            }
            builder::Builder::RecordDeclarationProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.default_value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::default_value)) {
                    b.default_value(v);
                }
                b.build(ctx)
            }
            builder::Builder::RecordDeclarationStaticProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.value.visit_child_mut(ctx, visitor, Path::new(self, NodeField::value)) {
                    b.value(v);
                }
                b.build(ctx)
            }
            builder::Builder::RecordExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.record_constructor.visit_child_mut(ctx, visitor, Path::new(self, NodeField::record_constructor)) {
                    b.record_constructor(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_arguments.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_arguments)) {
                    b.type_arguments(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.properties.visit_child_mut(ctx, visitor, Path::new(self, NodeField::properties)) {
                    b.properties(v);
                }
                b.build(ctx)
            }
            builder::Builder::RecordExpressionProperties(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.properties.visit_child_mut(ctx, visitor, Path::new(self, NodeField::properties)) {
                    b.properties(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypeAnnotation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSAnyKeyword(mut b) => b.build(ctx),
            builder::Builder::TSNumberKeyword(mut b) => b.build(ctx),
            builder::Builder::TSBooleanKeyword(mut b) => b.build(ctx),
            builder::Builder::TSStringKeyword(mut b) => b.build(ctx),
            builder::Builder::TSSymbolKeyword(mut b) => b.build(ctx),
            builder::Builder::TSVoidKeyword(mut b) => b.build(ctx),
            builder::Builder::TSUndefinedKeyword(mut b) => b.build(ctx),
            builder::Builder::TSUnknownKeyword(mut b) => b.build(ctx),
            builder::Builder::TSNeverKeyword(mut b) => b.build(ctx),
            builder::Builder::TSBigIntKeyword(mut b) => b.build(ctx),
            builder::Builder::TSThisType(mut b) => b.build(ctx),
            builder::Builder::TSLiteralType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.literal.visit_child_mut(ctx, visitor, Path::new(self, NodeField::literal)) {
                    b.literal(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSIndexedAccessType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.object_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::object_type)) {
                    b.object_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.index_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::index_type)) {
                    b.index_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSArrayType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.element_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::element_type)) {
                    b.element_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypeReference(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.type_name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_name)) {
                    b.type_name(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSQualifiedName(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.left.visit_child_mut(ctx, visitor, Path::new(self, NodeField::left)) {
                    b.left(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSFunctionType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSConstructorType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypePredicate(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.parameter_name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::parameter_name)) {
                    b.parameter_name(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTupleType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.element_types.visit_child_mut(ctx, visitor, Path::new(self, NodeField::element_types)) {
                    b.element_types(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypeAssertion(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSAsExpression(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSParameterProperty(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.parameter.visit_child_mut(ctx, visitor, Path::new(self, NodeField::parameter)) {
                    b.parameter(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypeAliasDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSInterfaceDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.extends.visit_child_mut(ctx, visitor, Path::new(self, NodeField::extends)) {
                    b.extends(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSInterfaceHeritage(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expression.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expression)) {
                    b.expression(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_parameters)) {
                    b.type_parameters(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSInterfaceBody(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSEnumDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.members.visit_child_mut(ctx, visitor, Path::new(self, NodeField::members)) {
                    b.members(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSEnumMember(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.initializer.visit_child_mut(ctx, visitor, Path::new(self, NodeField::initializer)) {
                    b.initializer(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSModuleDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSModuleBlock(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.body.visit_child_mut(ctx, visitor, Path::new(self, NodeField::body)) {
                    b.body(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSModuleMember(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.id.visit_child_mut(ctx, visitor, Path::new(self, NodeField::id)) {
                    b.id(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.initializer.visit_child_mut(ctx, visitor, Path::new(self, NodeField::initializer)) {
                    b.initializer(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypeParameterDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypeParameter(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::name)) {
                    b.name(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.constraint.visit_child_mut(ctx, visitor, Path::new(self, NodeField::constraint)) {
                    b.constraint(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.default.visit_child_mut(ctx, visitor, Path::new(self, NodeField::default)) {
                    b.default(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypeParameterInstantiation(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSUnionType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.types.visit_child_mut(ctx, visitor, Path::new(self, NodeField::types)) {
                    b.types(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSIntersectionType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.types.visit_child_mut(ctx, visitor, Path::new(self, NodeField::types)) {
                    b.types(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypeQuery(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.expr_name.visit_child_mut(ctx, visitor, Path::new(self, NodeField::expr_name)) {
                    b.expr_name(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSConditionalType(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.check_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::check_type)) {
                    b.check_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.extends_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::extends_type)) {
                    b.extends_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.true_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::true_type)) {
                    b.true_type(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.false_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::false_type)) {
                    b.false_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSTypeLiteral(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.members.visit_child_mut(ctx, visitor, Path::new(self, NodeField::members)) {
                    b.members(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSPropertySignature(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.initializer.visit_child_mut(ctx, visitor, Path::new(self, NodeField::initializer)) {
                    b.initializer(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSMethodSignature(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.key.visit_child_mut(ctx, visitor, Path::new(self, NodeField::key)) {
                    b.key(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSIndexSignature(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.parameters.visit_child_mut(ctx, visitor, Path::new(self, NodeField::parameters)) {
                    b.parameters(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.type_annotation.visit_child_mut(ctx, visitor, Path::new(self, NodeField::type_annotation)) {
                    b.type_annotation(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSCallSignatureDeclaration(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.params.visit_child_mut(ctx, visitor, Path::new(self, NodeField::params)) {
                    b.params(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.return_type.visit_child_mut(ctx, visitor, Path::new(self, NodeField::return_type)) {
                    b.return_type(v);
                }
                b.build(ctx)
            }
            builder::Builder::TSModifiers(mut b) => b.build(ctx),
            builder::Builder::CoverEmptyArgs(mut b) => b.build(ctx),
            builder::Builder::CoverTrailingComma(mut b) => b.build(ctx),
            builder::Builder::CoverInitializer(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.init.visit_child_mut(ctx, visitor, Path::new(self, NodeField::init)) {
                    b.init(v);
                }
                b.build(ctx)
            }
            builder::Builder::CoverRestElement(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.rest.visit_child_mut(ctx, visitor, Path::new(self, NodeField::rest)) {
                    b.rest(v);
                }
                b.build(ctx)
            }
            builder::Builder::CoverTypedIdentifier(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.left.visit_child_mut(ctx, visitor, Path::new(self, NodeField::left)) {
                    b.left(v);
                }
                if let TransformResult::Changed(v) =
                    b.inner.right.visit_child_mut(ctx, visitor, Path::new(self, NodeField::right)) {
                    b.right(v);
                }
                b.build(ctx)
            }
            builder::Builder::SHBuiltin(mut b) => b.build(ctx),
            builder::Builder::ImplicitCheckedCast(mut b) => {
                if let TransformResult::Changed(v) =
                    b.inner.argument.visit_child_mut(ctx, visitor, Path::new(self, NodeField::argument)) {
                    b.argument(v);
                }
                b.build(ctx)
            }
        }
    }

    /// Call `cb` on every `NodeList` field of this node, including
    /// decoration lists. Used by the GC to mark list elements.
    pub fn mark_lists<F: FnMut(&NodeList<'gc>)>(&'gc self, cb: &mut F) {
        match self {
            Node::Program(n) => { cb(&n.body); cb(&n.decorations.get()); cb(&n.dummy_param_list.get()); }
            Node::FunctionExpression(n) => { cb(&n.params); cb(&n.decorations.get()); }
            Node::ArrowFunctionExpression(n) => { cb(&n.params); cb(&n.decorations.get()); }
            Node::FunctionDeclaration(n) => { cb(&n.params); cb(&n.decorations.get()); }
            Node::ComponentDeclaration(n) => { cb(&n.params); cb(&n.decorations.get()); }
            Node::HookDeclaration(n) => { cb(&n.params); cb(&n.decorations.get()); }
            Node::MatchStatement(n) => { cb(&n.cases); }
            Node::BlockStatement(n) => { cb(&n.body); }
            Node::StaticBlock(n) => { cb(&n.body); }
            Node::SwitchStatement(n) => { cb(&n.cases); }
            Node::SequenceExpression(n) => { cb(&n.expressions); }
            Node::ObjectExpression(n) => { cb(&n.properties); }
            Node::ArrayExpression(n) => { cb(&n.elements); }
            Node::NewExpression(n) => { cb(&n.arguments); }
            Node::CallExpression(n) => { cb(&n.arguments); }
            Node::OptionalCallExpression(n) => { cb(&n.arguments); }
            Node::SwitchCase(n) => { cb(&n.consequent); }
            Node::VariableDeclaration(n) => { cb(&n.declarations); }
            Node::TemplateLiteral(n) => { cb(&n.quasis); cb(&n.expressions); }
            Node::ClassDeclaration(n) => { cb(&n.implements); cb(&n.decorators); }
            Node::ClassExpression(n) => { cb(&n.implements); cb(&n.decorators); }
            Node::ClassBody(n) => { cb(&n.body); }
            Node::ClassProperty(n) => { cb(&n.decorators); }
            Node::ClassPrivateProperty(n) => { cb(&n.decorators); }
            Node::MethodDefinition(n) => { cb(&n.decorators); }
            Node::ImportDeclaration(n) => { cb(&n.specifiers); cb(&n.attributes); }
            Node::ExportNamedDeclaration(n) => { cb(&n.specifiers); }
            Node::ObjectPattern(n) => { cb(&n.properties); }
            Node::ArrayPattern(n) => { cb(&n.elements); }
            Node::MatchExpression(n) => { cb(&n.cases); }
            Node::MatchObjectPattern(n) => { cb(&n.properties); }
            Node::MatchArrayPattern(n) => { cb(&n.elements); }
            Node::MatchOrPattern(n) => { cb(&n.patterns); }
            Node::MatchInstanceObjectPattern(n) => { cb(&n.properties); }
            Node::JSXOpeningElement(n) => { cb(&n.attributes); }
            Node::JSXElement(n) => { cb(&n.children); }
            Node::JSXFragment(n) => { cb(&n.children); }
            Node::FunctionTypeAnnotation(n) => { cb(&n.params); }
            Node::HookTypeAnnotation(n) => { cb(&n.params); }
            Node::ComponentTypeAnnotation(n) => { cb(&n.params); }
            Node::TupleTypeAnnotation(n) => { cb(&n.element_types); }
            Node::UnionTypeAnnotation(n) => { cb(&n.types); }
            Node::IntersectionTypeAnnotation(n) => { cb(&n.types); }
            Node::InterfaceTypeAnnotation(n) => { cb(&n.extends); }
            Node::InterfaceDeclaration(n) => { cb(&n.extends); }
            Node::DeclareInterface(n) => { cb(&n.extends); }
            Node::DeclareClass(n) => { cb(&n.extends); cb(&n.implements); cb(&n.mixins); }
            Node::DeclareComponent(n) => { cb(&n.params); }
            Node::DeclareExportDeclaration(n) => { cb(&n.specifiers); }
            Node::ObjectTypeAnnotation(n) => { cb(&n.properties); cb(&n.indexers); cb(&n.call_properties); cb(&n.internal_slots); }
            Node::TypeParameterDeclaration(n) => { cb(&n.params); }
            Node::TypeParameterInstantiation(n) => { cb(&n.params); }
            Node::EnumStringBody(n) => { cb(&n.members); }
            Node::EnumNumberBody(n) => { cb(&n.members); }
            Node::EnumBigIntBody(n) => { cb(&n.members); }
            Node::EnumBooleanBody(n) => { cb(&n.members); }
            Node::EnumSymbolBody(n) => { cb(&n.members); }
            Node::RecordDeclaration(n) => { cb(&n.implements); }
            Node::RecordDeclarationBody(n) => { cb(&n.elements); }
            Node::RecordExpressionProperties(n) => { cb(&n.properties); }
            Node::TSFunctionType(n) => { cb(&n.params); }
            Node::TSConstructorType(n) => { cb(&n.params); }
            Node::TSTupleType(n) => { cb(&n.element_types); }
            Node::TSInterfaceDeclaration(n) => { cb(&n.extends); }
            Node::TSInterfaceBody(n) => { cb(&n.body); }
            Node::TSEnumDeclaration(n) => { cb(&n.members); }
            Node::TSModuleBlock(n) => { cb(&n.body); }
            Node::TSTypeParameterDeclaration(n) => { cb(&n.params); }
            Node::TSTypeParameterInstantiation(n) => { cb(&n.params); }
            Node::TSUnionType(n) => { cb(&n.types); }
            Node::TSIntersectionType(n) => { cb(&n.types); }
            Node::TSTypeLiteral(n) => { cb(&n.members); }
            Node::TSMethodSignature(n) => { cb(&n.params); }
            Node::TSIndexSignature(n) => { cb(&n.parameters); }
            Node::TSCallSignatureDeclaration(n) => { cb(&n.params); }
            _ => {}
        }
    }

    /// The ESTree node type name — the JSON `"type"` value.
    pub fn node_type_str(&self) -> &'static str {
        match self {
            Node::Empty(_) => "Empty",
            Node::Metadata(_) => "Metadata",
            Node::Program(_) => "Program",
            Node::FunctionExpression(_) => "FunctionExpression",
            Node::ArrowFunctionExpression(_) => "ArrowFunctionExpression",
            Node::FunctionDeclaration(_) => "FunctionDeclaration",
            Node::ComponentDeclaration(_) => "ComponentDeclaration",
            Node::HookDeclaration(_) => "HookDeclaration",
            Node::MatchStatement(_) => "MatchStatement",
            Node::WhileStatement(_) => "WhileStatement",
            Node::DoWhileStatement(_) => "DoWhileStatement",
            Node::ForInStatement(_) => "ForInStatement",
            Node::ForOfStatement(_) => "ForOfStatement",
            Node::ForStatement(_) => "ForStatement",
            Node::DebuggerStatement(_) => "DebuggerStatement",
            Node::EmptyStatement(_) => "EmptyStatement",
            Node::BlockStatement(_) => "BlockStatement",
            Node::StaticBlock(_) => "StaticBlock",
            Node::BreakStatement(_) => "BreakStatement",
            Node::ContinueStatement(_) => "ContinueStatement",
            Node::ThrowStatement(_) => "ThrowStatement",
            Node::ReturnStatement(_) => "ReturnStatement",
            Node::WithStatement(_) => "WithStatement",
            Node::SwitchStatement(_) => "SwitchStatement",
            Node::LabeledStatement(_) => "LabeledStatement",
            Node::ExpressionStatement(_) => "ExpressionStatement",
            Node::TryStatement(_) => "TryStatement",
            Node::IfStatement(_) => "IfStatement",
            Node::NullLiteral(_) => "NullLiteral",
            Node::BooleanLiteral(_) => "BooleanLiteral",
            Node::StringLiteral(_) => "StringLiteral",
            Node::NumericLiteral(_) => "NumericLiteral",
            Node::RegExpLiteral(_) => "RegExpLiteral",
            Node::BigIntLiteral(_) => "BigIntLiteral",
            Node::ThisExpression(_) => "ThisExpression",
            Node::Super(_) => "Super",
            Node::SequenceExpression(_) => "SequenceExpression",
            Node::ObjectExpression(_) => "ObjectExpression",
            Node::ArrayExpression(_) => "ArrayExpression",
            Node::SpreadElement(_) => "SpreadElement",
            Node::NewExpression(_) => "NewExpression",
            Node::YieldExpression(_) => "YieldExpression",
            Node::AwaitExpression(_) => "AwaitExpression",
            Node::ImportExpression(_) => "ImportExpression",
            Node::CallExpression(_) => "CallExpression",
            Node::OptionalCallExpression(_) => "OptionalCallExpression",
            Node::AssignmentExpression(_) => "AssignmentExpression",
            Node::UnaryExpression(_) => "UnaryExpression",
            Node::UpdateExpression(_) => "UpdateExpression",
            Node::MemberExpression(_) => "MemberExpression",
            Node::OptionalMemberExpression(_) => "OptionalMemberExpression",
            Node::LogicalExpression(_) => "LogicalExpression",
            Node::ConditionalExpression(_) => "ConditionalExpression",
            Node::BinaryExpression(_) => "BinaryExpression",
            Node::Directive(_) => "Directive",
            Node::DirectiveLiteral(_) => "DirectiveLiteral",
            Node::Identifier(_) => "Identifier",
            Node::PrivateName(_) => "PrivateName",
            Node::MetaProperty(_) => "MetaProperty",
            Node::SwitchCase(_) => "SwitchCase",
            Node::CatchClause(_) => "CatchClause",
            Node::VariableDeclarator(_) => "VariableDeclarator",
            Node::VariableDeclaration(_) => "VariableDeclaration",
            Node::TemplateLiteral(_) => "TemplateLiteral",
            Node::TaggedTemplateExpression(_) => "TaggedTemplateExpression",
            Node::TemplateElement(_) => "TemplateElement",
            Node::Property(_) => "Property",
            Node::Decorator(_) => "Decorator",
            Node::ClassDeclaration(_) => "ClassDeclaration",
            Node::ClassExpression(_) => "ClassExpression",
            Node::ClassBody(_) => "ClassBody",
            Node::ClassProperty(_) => "ClassProperty",
            Node::ClassPrivateProperty(_) => "ClassPrivateProperty",
            Node::MethodDefinition(_) => "MethodDefinition",
            Node::ImportDeclaration(_) => "ImportDeclaration",
            Node::ImportSpecifier(_) => "ImportSpecifier",
            Node::ImportDefaultSpecifier(_) => "ImportDefaultSpecifier",
            Node::ImportNamespaceSpecifier(_) => "ImportNamespaceSpecifier",
            Node::ImportAttribute(_) => "ImportAttribute",
            Node::ExportNamedDeclaration(_) => "ExportNamedDeclaration",
            Node::ExportSpecifier(_) => "ExportSpecifier",
            Node::ExportNamespaceSpecifier(_) => "ExportNamespaceSpecifier",
            Node::ExportDefaultDeclaration(_) => "ExportDefaultDeclaration",
            Node::ExportAllDeclaration(_) => "ExportAllDeclaration",
            Node::ObjectPattern(_) => "ObjectPattern",
            Node::ArrayPattern(_) => "ArrayPattern",
            Node::RestElement(_) => "RestElement",
            Node::AssignmentPattern(_) => "AssignmentPattern",
            Node::MatchStatementCase(_) => "MatchStatementCase",
            Node::MatchExpression(_) => "MatchExpression",
            Node::MatchExpressionCase(_) => "MatchExpressionCase",
            Node::MatchWildcardPattern(_) => "MatchWildcardPattern",
            Node::MatchLiteralPattern(_) => "MatchLiteralPattern",
            Node::MatchUnaryPattern(_) => "MatchUnaryPattern",
            Node::MatchIdentifierPattern(_) => "MatchIdentifierPattern",
            Node::MatchBindingPattern(_) => "MatchBindingPattern",
            Node::MatchObjectPattern(_) => "MatchObjectPattern",
            Node::MatchArrayPattern(_) => "MatchArrayPattern",
            Node::MatchOrPattern(_) => "MatchOrPattern",
            Node::MatchAsPattern(_) => "MatchAsPattern",
            Node::MatchMemberPattern(_) => "MatchMemberPattern",
            Node::MatchInstancePattern(_) => "MatchInstancePattern",
            Node::MatchObjectPatternProperty(_) => "MatchObjectPatternProperty",
            Node::MatchInstanceObjectPattern(_) => "MatchInstanceObjectPattern",
            Node::MatchRestPattern(_) => "MatchRestPattern",
            Node::JSXIdentifier(_) => "JSXIdentifier",
            Node::JSXMemberExpression(_) => "JSXMemberExpression",
            Node::JSXNamespacedName(_) => "JSXNamespacedName",
            Node::JSXEmptyExpression(_) => "JSXEmptyExpression",
            Node::JSXExpressionContainer(_) => "JSXExpressionContainer",
            Node::JSXSpreadChild(_) => "JSXSpreadChild",
            Node::JSXOpeningElement(_) => "JSXOpeningElement",
            Node::JSXClosingElement(_) => "JSXClosingElement",
            Node::JSXAttribute(_) => "JSXAttribute",
            Node::JSXSpreadAttribute(_) => "JSXSpreadAttribute",
            Node::JSXStringLiteral(_) => "JSXStringLiteral",
            Node::JSXText(_) => "JSXText",
            Node::JSXElement(_) => "JSXElement",
            Node::JSXFragment(_) => "JSXFragment",
            Node::JSXOpeningFragment(_) => "JSXOpeningFragment",
            Node::JSXClosingFragment(_) => "JSXClosingFragment",
            Node::ExistsTypeAnnotation(_) => "ExistsTypeAnnotation",
            Node::EmptyTypeAnnotation(_) => "EmptyTypeAnnotation",
            Node::StringTypeAnnotation(_) => "StringTypeAnnotation",
            Node::NumberTypeAnnotation(_) => "NumberTypeAnnotation",
            Node::StringLiteralTypeAnnotation(_) => "StringLiteralTypeAnnotation",
            Node::NumberLiteralTypeAnnotation(_) => "NumberLiteralTypeAnnotation",
            Node::BigIntLiteralTypeAnnotation(_) => "BigIntLiteralTypeAnnotation",
            Node::BooleanTypeAnnotation(_) => "BooleanTypeAnnotation",
            Node::BooleanLiteralTypeAnnotation(_) => "BooleanLiteralTypeAnnotation",
            Node::NullLiteralTypeAnnotation(_) => "NullLiteralTypeAnnotation",
            Node::SymbolTypeAnnotation(_) => "SymbolTypeAnnotation",
            Node::AnyTypeAnnotation(_) => "AnyTypeAnnotation",
            Node::MixedTypeAnnotation(_) => "MixedTypeAnnotation",
            Node::BigIntTypeAnnotation(_) => "BigIntTypeAnnotation",
            Node::VoidTypeAnnotation(_) => "VoidTypeAnnotation",
            Node::NeverTypeAnnotation(_) => "NeverTypeAnnotation",
            Node::UnknownTypeAnnotation(_) => "UnknownTypeAnnotation",
            Node::UndefinedTypeAnnotation(_) => "UndefinedTypeAnnotation",
            Node::FunctionTypeAnnotation(_) => "FunctionTypeAnnotation",
            Node::HookTypeAnnotation(_) => "HookTypeAnnotation",
            Node::FunctionTypeParam(_) => "FunctionTypeParam",
            Node::ComponentTypeAnnotation(_) => "ComponentTypeAnnotation",
            Node::ComponentTypeParameter(_) => "ComponentTypeParameter",
            Node::NullableTypeAnnotation(_) => "NullableTypeAnnotation",
            Node::QualifiedTypeIdentifier(_) => "QualifiedTypeIdentifier",
            Node::TypeofTypeAnnotation(_) => "TypeofTypeAnnotation",
            Node::KeyofTypeAnnotation(_) => "KeyofTypeAnnotation",
            Node::TypeOperator(_) => "TypeOperator",
            Node::QualifiedTypeofIdentifier(_) => "QualifiedTypeofIdentifier",
            Node::TupleTypeAnnotation(_) => "TupleTypeAnnotation",
            Node::TupleTypeSpreadElement(_) => "TupleTypeSpreadElement",
            Node::TupleTypeLabeledElement(_) => "TupleTypeLabeledElement",
            Node::ArrayTypeAnnotation(_) => "ArrayTypeAnnotation",
            Node::InferTypeAnnotation(_) => "InferTypeAnnotation",
            Node::UnionTypeAnnotation(_) => "UnionTypeAnnotation",
            Node::IntersectionTypeAnnotation(_) => "IntersectionTypeAnnotation",
            Node::GenericTypeAnnotation(_) => "GenericTypeAnnotation",
            Node::IndexedAccessType(_) => "IndexedAccessType",
            Node::OptionalIndexedAccessType(_) => "OptionalIndexedAccessType",
            Node::ConditionalTypeAnnotation(_) => "ConditionalTypeAnnotation",
            Node::TypePredicate(_) => "TypePredicate",
            Node::InterfaceTypeAnnotation(_) => "InterfaceTypeAnnotation",
            Node::TypeAlias(_) => "TypeAlias",
            Node::OpaqueType(_) => "OpaqueType",
            Node::InterfaceDeclaration(_) => "InterfaceDeclaration",
            Node::DeclareTypeAlias(_) => "DeclareTypeAlias",
            Node::DeclareOpaqueType(_) => "DeclareOpaqueType",
            Node::DeclareInterface(_) => "DeclareInterface",
            Node::DeclareClass(_) => "DeclareClass",
            Node::DeclareFunction(_) => "DeclareFunction",
            Node::DeclareHook(_) => "DeclareHook",
            Node::DeclareComponent(_) => "DeclareComponent",
            Node::DeclareVariable(_) => "DeclareVariable",
            Node::DeclareEnum(_) => "DeclareEnum",
            Node::DeclareExportDeclaration(_) => "DeclareExportDeclaration",
            Node::DeclareExportAllDeclaration(_) => "DeclareExportAllDeclaration",
            Node::DeclareModule(_) => "DeclareModule",
            Node::DeclareNamespace(_) => "DeclareNamespace",
            Node::DeclareModuleExports(_) => "DeclareModuleExports",
            Node::InterfaceExtends(_) => "InterfaceExtends",
            Node::ClassImplements(_) => "ClassImplements",
            Node::TypeAnnotation(_) => "TypeAnnotation",
            Node::ObjectTypeAnnotation(_) => "ObjectTypeAnnotation",
            Node::ObjectTypeProperty(_) => "ObjectTypeProperty",
            Node::ObjectTypeSpreadProperty(_) => "ObjectTypeSpreadProperty",
            Node::ObjectTypeInternalSlot(_) => "ObjectTypeInternalSlot",
            Node::ObjectTypeCallProperty(_) => "ObjectTypeCallProperty",
            Node::ObjectTypeIndexer(_) => "ObjectTypeIndexer",
            Node::ObjectTypeMappedTypeProperty(_) => "ObjectTypeMappedTypeProperty",
            Node::Variance(_) => "Variance",
            Node::TypeParameterDeclaration(_) => "TypeParameterDeclaration",
            Node::TypeParameter(_) => "TypeParameter",
            Node::TypeParameterInstantiation(_) => "TypeParameterInstantiation",
            Node::TypeCastExpression(_) => "TypeCastExpression",
            Node::AsExpression(_) => "AsExpression",
            Node::AsConstExpression(_) => "AsConstExpression",
            Node::InferredPredicate(_) => "InferredPredicate",
            Node::DeclaredPredicate(_) => "DeclaredPredicate",
            Node::EnumDeclaration(_) => "EnumDeclaration",
            Node::EnumStringBody(_) => "EnumStringBody",
            Node::EnumNumberBody(_) => "EnumNumberBody",
            Node::EnumBigIntBody(_) => "EnumBigIntBody",
            Node::EnumBooleanBody(_) => "EnumBooleanBody",
            Node::EnumSymbolBody(_) => "EnumSymbolBody",
            Node::EnumDefaultedMember(_) => "EnumDefaultedMember",
            Node::EnumStringMember(_) => "EnumStringMember",
            Node::EnumNumberMember(_) => "EnumNumberMember",
            Node::EnumBigIntMember(_) => "EnumBigIntMember",
            Node::EnumBooleanMember(_) => "EnumBooleanMember",
            Node::ComponentParameter(_) => "ComponentParameter",
            Node::RecordDeclaration(_) => "RecordDeclaration",
            Node::RecordDeclarationImplements(_) => "RecordDeclarationImplements",
            Node::RecordDeclarationBody(_) => "RecordDeclarationBody",
            Node::RecordDeclarationProperty(_) => "RecordDeclarationProperty",
            Node::RecordDeclarationStaticProperty(_) => "RecordDeclarationStaticProperty",
            Node::RecordExpression(_) => "RecordExpression",
            Node::RecordExpressionProperties(_) => "RecordExpressionProperties",
            Node::TSTypeAnnotation(_) => "TSTypeAnnotation",
            Node::TSAnyKeyword(_) => "TSAnyKeyword",
            Node::TSNumberKeyword(_) => "TSNumberKeyword",
            Node::TSBooleanKeyword(_) => "TSBooleanKeyword",
            Node::TSStringKeyword(_) => "TSStringKeyword",
            Node::TSSymbolKeyword(_) => "TSSymbolKeyword",
            Node::TSVoidKeyword(_) => "TSVoidKeyword",
            Node::TSUndefinedKeyword(_) => "TSUndefinedKeyword",
            Node::TSUnknownKeyword(_) => "TSUnknownKeyword",
            Node::TSNeverKeyword(_) => "TSNeverKeyword",
            Node::TSBigIntKeyword(_) => "TSBigIntKeyword",
            Node::TSThisType(_) => "TSThisType",
            Node::TSLiteralType(_) => "TSLiteralType",
            Node::TSIndexedAccessType(_) => "TSIndexedAccessType",
            Node::TSArrayType(_) => "TSArrayType",
            Node::TSTypeReference(_) => "TSTypeReference",
            Node::TSQualifiedName(_) => "TSQualifiedName",
            Node::TSFunctionType(_) => "TSFunctionType",
            Node::TSConstructorType(_) => "TSConstructorType",
            Node::TSTypePredicate(_) => "TSTypePredicate",
            Node::TSTupleType(_) => "TSTupleType",
            Node::TSTypeAssertion(_) => "TSTypeAssertion",
            Node::TSAsExpression(_) => "TSAsExpression",
            Node::TSParameterProperty(_) => "TSParameterProperty",
            Node::TSTypeAliasDeclaration(_) => "TSTypeAliasDeclaration",
            Node::TSInterfaceDeclaration(_) => "TSInterfaceDeclaration",
            Node::TSInterfaceHeritage(_) => "TSInterfaceHeritage",
            Node::TSInterfaceBody(_) => "TSInterfaceBody",
            Node::TSEnumDeclaration(_) => "TSEnumDeclaration",
            Node::TSEnumMember(_) => "TSEnumMember",
            Node::TSModuleDeclaration(_) => "TSModuleDeclaration",
            Node::TSModuleBlock(_) => "TSModuleBlock",
            Node::TSModuleMember(_) => "TSModuleMember",
            Node::TSTypeParameterDeclaration(_) => "TSTypeParameterDeclaration",
            Node::TSTypeParameter(_) => "TSTypeParameter",
            Node::TSTypeParameterInstantiation(_) => "TSTypeParameterInstantiation",
            Node::TSUnionType(_) => "TSUnionType",
            Node::TSIntersectionType(_) => "TSIntersectionType",
            Node::TSTypeQuery(_) => "TSTypeQuery",
            Node::TSConditionalType(_) => "TSConditionalType",
            Node::TSTypeLiteral(_) => "TSTypeLiteral",
            Node::TSPropertySignature(_) => "TSPropertySignature",
            Node::TSMethodSignature(_) => "TSMethodSignature",
            Node::TSIndexSignature(_) => "TSIndexSignature",
            Node::TSCallSignatureDeclaration(_) => "TSCallSignatureDeclaration",
            Node::TSModifiers(_) => "TSModifiers",
            Node::CoverEmptyArgs(_) => "CoverEmptyArgs",
            Node::CoverTrailingComma(_) => "CoverTrailingComma",
            Node::CoverInitializer(_) => "CoverInitializer",
            Node::CoverRestElement(_) => "CoverRestElement",
            Node::CoverTypedIdentifier(_) => "CoverTypedIdentifier",
            Node::SHBuiltin(_) => "SHBuiltin",
            Node::ImplicitCheckedCast(_) => "ImplicitCheckedCast",
        }
    }

    /// Emit this node's `.def` child fields as JSON key/values,
    /// in declared order. Mirrors C++ `visitChildren`.
    pub fn dump_children<'a, 'w>(
        &'gc self,
        d: &mut crate::dump::ESTreeJSONDumper<'a, 'w>,
    ) {
        match self {
            Node::Empty(_) => {}
            Node::Metadata(_) => {}
            Node::Program(n) => {
                d.field_list("body", n.body, false);
            }
            Node::FunctionExpression(n) => {
                d.field_node("id", n.id, false);
                d.field_list("params", n.params, false);
                d.field_node("body", Some(n.body), false);
                d.field_node("typeParameters", n.type_parameters, true);
                d.field_node("returnType", n.return_type, true);
                d.field_node("predicate", n.predicate, true);
                d.field_bool("generator", n.generator.get(), false);
                d.field_bool("async", n.r#async.get(), false);
            }
            Node::ArrowFunctionExpression(n) => {
                d.field_list("params", n.params, false);
                d.field_node("body", Some(n.body), false);
                d.field_node("typeParameters", n.type_parameters, true);
                d.field_node("returnType", n.return_type, true);
                d.field_node("predicate", n.predicate, true);
                d.field_bool("expression", n.expression.get(), false);
                d.field_bool("async", n.r#async.get(), false);
            }
            Node::FunctionDeclaration(n) => {
                d.field_node("id", n.id, false);
                d.field_list("params", n.params, false);
                d.field_node("body", Some(n.body), false);
                d.field_node("typeParameters", n.type_parameters, true);
                d.field_node("returnType", n.return_type, true);
                d.field_node("predicate", n.predicate, true);
                d.field_bool("generator", n.generator.get(), false);
                d.field_bool("async", n.r#async.get(), false);
            }
            Node::ComponentDeclaration(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_list("params", n.params, false);
                d.field_node("body", Some(n.body), false);
                d.field_node("typeParameters", n.type_parameters, true);
                d.field_node("rendersType", n.renders_type, true);
                d.field_bool("async", n.r#async.get(), false);
            }
            Node::HookDeclaration(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_list("params", n.params, false);
                d.field_node("body", Some(n.body), false);
                d.field_node("typeParameters", n.type_parameters, true);
                d.field_node("returnType", n.return_type, true);
                d.field_bool("async", n.r#async.get(), false);
            }
            Node::MatchStatement(n) => {
                d.field_node("argument", Some(n.argument), false);
                d.field_list("cases", n.cases, false);
            }
            Node::WhileStatement(n) => {
                d.field_node("body", Some(n.body), false);
                d.field_node("test", Some(n.test), false);
            }
            Node::DoWhileStatement(n) => {
                d.field_node("body", Some(n.body), false);
                d.field_node("test", Some(n.test), false);
            }
            Node::ForInStatement(n) => {
                d.field_node("left", Some(n.left), false);
                d.field_node("right", Some(n.right), false);
                d.field_node("body", Some(n.body), false);
            }
            Node::ForOfStatement(n) => {
                d.field_node("left", Some(n.left), false);
                d.field_node("right", Some(n.right), false);
                d.field_node("body", Some(n.body), false);
                d.field_bool("await", n.r#await.get(), false);
            }
            Node::ForStatement(n) => {
                d.field_node("init", n.init, false);
                d.field_node("test", n.test, false);
                d.field_node("update", n.update, false);
                d.field_node("body", Some(n.body), false);
            }
            Node::DebuggerStatement(_) => {}
            Node::EmptyStatement(_) => {}
            Node::BlockStatement(n) => {
                d.field_list("body", n.body, false);
                d.field_bool("implicit", n.implicit.get(), true);
            }
            Node::StaticBlock(n) => {
                d.field_list("body", n.body, false);
            }
            Node::BreakStatement(n) => {
                d.field_node("label", n.label, false);
            }
            Node::ContinueStatement(n) => {
                d.field_node("label", n.label, false);
            }
            Node::ThrowStatement(n) => {
                d.field_node("argument", Some(n.argument), false);
            }
            Node::ReturnStatement(n) => {
                d.field_node("argument", n.argument, false);
            }
            Node::WithStatement(n) => {
                d.field_node("object", Some(n.object), false);
                d.field_node("body", Some(n.body), false);
            }
            Node::SwitchStatement(n) => {
                d.field_node("discriminant", Some(n.discriminant), false);
                d.field_list("cases", n.cases, false);
            }
            Node::LabeledStatement(n) => {
                d.field_node("label", Some(n.label), false);
                d.field_node("body", Some(n.body), false);
            }
            Node::ExpressionStatement(n) => {
                d.field_node("expression", Some(n.expression), false);
                d.field_label("directive", n.directive.get(), false);
            }
            Node::TryStatement(n) => {
                d.field_node("block", Some(n.block), false);
                d.field_node("handler", n.handler, false);
                d.field_node("finalizer", n.finalizer, false);
            }
            Node::IfStatement(n) => {
                d.field_node("test", Some(n.test), false);
                d.field_node("consequent", Some(n.consequent), false);
                d.field_node("alternate", n.alternate, false);
            }
            Node::NullLiteral(_) => {}
            Node::BooleanLiteral(n) => {
                d.field_bool("value", n.value.get(), false);
            }
            Node::StringLiteral(n) => {
                d.field_label("value", n.value.get(), false);
            }
            Node::NumericLiteral(n) => {
                d.field_number("value", n.value.get(), false);
            }
            Node::RegExpLiteral(n) => {
                d.field_label("pattern", n.pattern.get(), false);
                d.field_label("flags", n.flags.get(), false);
            }
            Node::BigIntLiteral(n) => {
                d.field_label("bigint", n.bigint.get(), false);
            }
            Node::ThisExpression(_) => {}
            Node::Super(_) => {}
            Node::SequenceExpression(n) => {
                d.field_list("expressions", n.expressions, false);
            }
            Node::ObjectExpression(n) => {
                d.field_list("properties", n.properties, false);
            }
            Node::ArrayExpression(n) => {
                d.field_list("elements", n.elements, false);
                d.field_bool("trailingComma", n.trailing_comma.get(), false);
            }
            Node::SpreadElement(n) => {
                d.field_node("argument", Some(n.argument), false);
            }
            Node::NewExpression(n) => {
                d.field_node("callee", Some(n.callee), false);
                d.field_node("typeArguments", n.type_arguments, true);
                d.field_list("arguments", n.arguments, false);
            }
            Node::YieldExpression(n) => {
                d.field_node("argument", n.argument, false);
                d.field_bool("delegate", n.delegate.get(), false);
            }
            Node::AwaitExpression(n) => {
                d.field_node("argument", Some(n.argument), false);
            }
            Node::ImportExpression(n) => {
                d.field_node("source", Some(n.source), false);
                d.field_node("options", n.options, false);
            }
            Node::CallExpression(n) => {
                d.field_node("callee", Some(n.callee), false);
                d.field_node("typeArguments", n.type_arguments, true);
                d.field_list("arguments", n.arguments, false);
            }
            Node::OptionalCallExpression(n) => {
                d.field_node("callee", Some(n.callee), false);
                d.field_node("typeArguments", n.type_arguments, true);
                d.field_list("arguments", n.arguments, false);
                d.field_bool("optional", n.optional.get(), false);
            }
            Node::AssignmentExpression(n) => {
                d.field_label("operator", n.operator.get(), false);
                d.field_node("left", Some(n.left), false);
                d.field_node("right", Some(n.right), false);
            }
            Node::UnaryExpression(n) => {
                d.field_label("operator", n.operator.get(), false);
                d.field_node("argument", Some(n.argument), false);
                d.field_bool("prefix", n.prefix.get(), false);
            }
            Node::UpdateExpression(n) => {
                d.field_label("operator", n.operator.get(), false);
                d.field_node("argument", Some(n.argument), false);
                d.field_bool("prefix", n.prefix.get(), false);
            }
            Node::MemberExpression(n) => {
                d.field_node("object", Some(n.object), false);
                d.field_node("property", Some(n.property), false);
                d.field_bool("computed", n.computed.get(), false);
            }
            Node::OptionalMemberExpression(n) => {
                d.field_node("object", Some(n.object), false);
                d.field_node("property", Some(n.property), false);
                d.field_bool("computed", n.computed.get(), false);
                d.field_bool("optional", n.optional.get(), false);
            }
            Node::LogicalExpression(n) => {
                d.field_node("left", Some(n.left), false);
                d.field_node("right", Some(n.right), false);
                d.field_label("operator", n.operator.get(), false);
            }
            Node::ConditionalExpression(n) => {
                d.field_node("test", Some(n.test), false);
                d.field_node("alternate", Some(n.alternate), false);
                d.field_node("consequent", Some(n.consequent), false);
            }
            Node::BinaryExpression(n) => {
                d.field_node("left", Some(n.left), false);
                d.field_node("right", Some(n.right), false);
                d.field_label("operator", n.operator.get(), false);
            }
            Node::Directive(n) => {
                d.field_node("value", Some(n.value), false);
            }
            Node::DirectiveLiteral(n) => {
                d.field_label("value", n.value.get(), false);
            }
            Node::Identifier(n) => {
                d.field_label("name", n.name.get(), false);
                d.field_node("typeAnnotation", n.type_annotation, true);
                d.field_bool("optional", n.optional.get(), true);
            }
            Node::PrivateName(n) => {
                d.field_node("id", Some(n.id), false);
            }
            Node::MetaProperty(n) => {
                d.field_node("meta", Some(n.meta), false);
                d.field_node("property", Some(n.property), false);
            }
            Node::SwitchCase(n) => {
                d.field_node("test", n.test, false);
                d.field_list("consequent", n.consequent, false);
            }
            Node::CatchClause(n) => {
                d.field_node("param", n.param, false);
                d.field_node("body", Some(n.body), false);
            }
            Node::VariableDeclarator(n) => {
                d.field_node("init", n.init, false);
                d.field_node("id", Some(n.id), false);
            }
            Node::VariableDeclaration(n) => {
                d.field_label("kind", n.kind.get(), false);
                d.field_list("declarations", n.declarations, false);
            }
            Node::TemplateLiteral(n) => {
                d.field_list("quasis", n.quasis, false);
                d.field_list("expressions", n.expressions, false);
            }
            Node::TaggedTemplateExpression(n) => {
                d.field_node("tag", Some(n.tag), false);
                d.field_node("quasi", Some(n.quasi), false);
            }
            Node::TemplateElement(n) => {
                d.field_bool("tail", n.tail.get(), false);
                d.field_label("cooked", n.cooked.get(), false);
                d.field_label("raw", n.raw.get(), false);
            }
            Node::Property(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("value", Some(n.value), false);
                d.field_label("kind", n.kind.get(), false);
                d.field_bool("computed", n.computed.get(), false);
                d.field_bool("method", n.method.get(), false);
                d.field_bool("shorthand", n.shorthand.get(), false);
            }
            Node::Decorator(n) => {
                d.field_node("expression", Some(n.expression), false);
            }
            Node::ClassDeclaration(n) => {
                d.field_node("id", n.id, false);
                d.field_node("typeParameters", n.type_parameters, true);
                d.field_node("superClass", n.super_class, false);
                d.field_node("superTypeArguments", n.super_type_arguments, true);
                d.field_list("implements", n.implements, true);
                d.field_list("decorators", n.decorators, true);
                d.field_node("body", Some(n.body), false);
            }
            Node::ClassExpression(n) => {
                d.field_node("id", n.id, false);
                d.field_node("typeParameters", n.type_parameters, true);
                d.field_node("superClass", n.super_class, false);
                d.field_node("superTypeArguments", n.super_type_arguments, true);
                d.field_list("implements", n.implements, true);
                d.field_list("decorators", n.decorators, true);
                d.field_node("body", Some(n.body), false);
            }
            Node::ClassBody(n) => {
                d.field_list("body", n.body, false);
            }
            Node::ClassProperty(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("value", n.value, false);
                d.field_bool("computed", n.computed.get(), false);
                d.field_bool("static", n.r#static.get(), false);
                d.field_list("decorators", n.decorators, true);
                d.field_bool("declare", n.declare.get(), false);
                d.field_bool("optional", n.optional.get(), true);
                d.field_node("variance", n.variance, true);
                d.field_node("typeAnnotation", n.type_annotation, true);
                d.field_node("tsModifiers", n.ts_modifiers, true);
            }
            Node::ClassPrivateProperty(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("value", n.value, false);
                d.field_bool("static", n.r#static.get(), false);
                d.field_list("decorators", n.decorators, true);
                d.field_bool("declare", n.declare.get(), false);
                d.field_bool("optional", n.optional.get(), true);
                d.field_node("variance", n.variance, true);
                d.field_node("typeAnnotation", n.type_annotation, true);
                d.field_node("tsModifiers", n.ts_modifiers, true);
            }
            Node::MethodDefinition(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("value", Some(n.value), false);
                d.field_label("kind", n.kind.get(), false);
                d.field_bool("computed", n.computed.get(), false);
                d.field_bool("static", n.r#static.get(), false);
                d.field_list("decorators", n.decorators, true);
            }
            Node::ImportDeclaration(n) => {
                d.field_list("specifiers", n.specifiers, false);
                d.field_node("source", Some(n.source), false);
                d.field_list("attributes", n.attributes, false);
                d.field_label("importKind", n.import_kind.get(), false);
            }
            Node::ImportSpecifier(n) => {
                d.field_node("imported", Some(n.imported), false);
                d.field_node("local", Some(n.local), false);
                d.field_label("importKind", n.import_kind.get(), false);
            }
            Node::ImportDefaultSpecifier(n) => {
                d.field_node("local", Some(n.local), false);
            }
            Node::ImportNamespaceSpecifier(n) => {
                d.field_node("local", Some(n.local), false);
            }
            Node::ImportAttribute(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("value", Some(n.value), false);
            }
            Node::ExportNamedDeclaration(n) => {
                d.field_node("declaration", n.declaration, false);
                d.field_list("specifiers", n.specifiers, false);
                d.field_node("source", n.source, false);
                d.field_label("exportKind", n.export_kind.get(), false);
            }
            Node::ExportSpecifier(n) => {
                d.field_node("exported", Some(n.exported), false);
                d.field_node("local", Some(n.local), false);
            }
            Node::ExportNamespaceSpecifier(n) => {
                d.field_node("exported", Some(n.exported), false);
            }
            Node::ExportDefaultDeclaration(n) => {
                d.field_node("declaration", Some(n.declaration), false);
            }
            Node::ExportAllDeclaration(n) => {
                d.field_node("source", Some(n.source), false);
                d.field_label("exportKind", n.export_kind.get(), false);
            }
            Node::ObjectPattern(n) => {
                d.field_list("properties", n.properties, false);
                d.field_node("typeAnnotation", n.type_annotation, true);
            }
            Node::ArrayPattern(n) => {
                d.field_list("elements", n.elements, false);
                d.field_node("typeAnnotation", n.type_annotation, true);
            }
            Node::RestElement(n) => {
                d.field_node("argument", Some(n.argument), false);
            }
            Node::AssignmentPattern(n) => {
                d.field_node("left", Some(n.left), false);
                d.field_node("right", Some(n.right), false);
            }
            Node::MatchStatementCase(n) => {
                d.field_node("pattern", Some(n.pattern), false);
                d.field_node("body", Some(n.body), false);
                d.field_node("guard", n.guard, false);
            }
            Node::MatchExpression(n) => {
                d.field_node("argument", Some(n.argument), false);
                d.field_list("cases", n.cases, false);
            }
            Node::MatchExpressionCase(n) => {
                d.field_node("pattern", Some(n.pattern), false);
                d.field_node("body", Some(n.body), false);
                d.field_node("guard", n.guard, false);
            }
            Node::MatchWildcardPattern(_) => {}
            Node::MatchLiteralPattern(n) => {
                d.field_node("literal", Some(n.literal), false);
            }
            Node::MatchUnaryPattern(n) => {
                d.field_node("argument", Some(n.argument), false);
                d.field_label("operator", n.operator.get(), false);
            }
            Node::MatchIdentifierPattern(n) => {
                d.field_node("id", Some(n.id), false);
            }
            Node::MatchBindingPattern(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_label("kind", n.kind.get(), false);
            }
            Node::MatchObjectPattern(n) => {
                d.field_list("properties", n.properties, false);
                d.field_node("rest", n.rest, false);
            }
            Node::MatchArrayPattern(n) => {
                d.field_list("elements", n.elements, false);
                d.field_node("rest", n.rest, false);
            }
            Node::MatchOrPattern(n) => {
                d.field_list("patterns", n.patterns, false);
            }
            Node::MatchAsPattern(n) => {
                d.field_node("pattern", Some(n.pattern), false);
                d.field_node("target", Some(n.target), false);
            }
            Node::MatchMemberPattern(n) => {
                d.field_node("base", Some(n.base), false);
                d.field_node("property", Some(n.property), false);
            }
            Node::MatchInstancePattern(n) => {
                d.field_node("targetConstructor", Some(n.target_constructor), false);
                d.field_node("properties", Some(n.properties), false);
            }
            Node::MatchObjectPatternProperty(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("pattern", Some(n.pattern), false);
                d.field_bool("shorthand", n.shorthand.get(), false);
            }
            Node::MatchInstanceObjectPattern(n) => {
                d.field_list("properties", n.properties, false);
                d.field_node("rest", n.rest, false);
            }
            Node::MatchRestPattern(n) => {
                d.field_node("argument", n.argument, false);
            }
            Node::JSXIdentifier(n) => {
                d.field_label("name", n.name.get(), false);
            }
            Node::JSXMemberExpression(n) => {
                d.field_node("object", Some(n.object), false);
                d.field_node("property", Some(n.property), false);
            }
            Node::JSXNamespacedName(n) => {
                d.field_node("namespace", Some(n.namespace), false);
                d.field_node("name", Some(n.name), false);
            }
            Node::JSXEmptyExpression(_) => {}
            Node::JSXExpressionContainer(n) => {
                d.field_node("expression", Some(n.expression), false);
            }
            Node::JSXSpreadChild(n) => {
                d.field_node("expression", Some(n.expression), false);
            }
            Node::JSXOpeningElement(n) => {
                d.field_node("name", Some(n.name), false);
                d.field_list("attributes", n.attributes, false);
                d.field_bool("selfClosing", n.self_closing.get(), false);
                d.field_node("typeArguments", n.type_arguments, true);
            }
            Node::JSXClosingElement(n) => {
                d.field_node("name", Some(n.name), false);
            }
            Node::JSXAttribute(n) => {
                d.field_node("name", Some(n.name), false);
                d.field_node("value", n.value, false);
            }
            Node::JSXSpreadAttribute(n) => {
                d.field_node("argument", Some(n.argument), false);
            }
            Node::JSXStringLiteral(n) => {
                d.field_label("value", n.value.get(), false);
                d.field_label("raw", n.raw.get(), false);
            }
            Node::JSXText(n) => {
                d.field_label("value", n.value.get(), false);
                d.field_label("raw", n.raw.get(), false);
            }
            Node::JSXElement(n) => {
                d.field_node("openingElement", Some(n.opening_element), false);
                d.field_list("children", n.children, false);
                d.field_node("closingElement", n.closing_element, false);
            }
            Node::JSXFragment(n) => {
                d.field_node("openingFragment", Some(n.opening_fragment), false);
                d.field_list("children", n.children, false);
                d.field_node("closingFragment", Some(n.closing_fragment), false);
            }
            Node::JSXOpeningFragment(_) => {}
            Node::JSXClosingFragment(_) => {}
            Node::ExistsTypeAnnotation(_) => {}
            Node::EmptyTypeAnnotation(_) => {}
            Node::StringTypeAnnotation(_) => {}
            Node::NumberTypeAnnotation(_) => {}
            Node::StringLiteralTypeAnnotation(n) => {
                d.field_label("value", n.value.get(), false);
                d.field_label("raw", n.raw.get(), false);
            }
            Node::NumberLiteralTypeAnnotation(n) => {
                d.field_number("value", n.value.get(), false);
                d.field_label("raw", n.raw.get(), false);
            }
            Node::BigIntLiteralTypeAnnotation(n) => {
                d.field_label("raw", n.raw.get(), false);
            }
            Node::BooleanTypeAnnotation(_) => {}
            Node::BooleanLiteralTypeAnnotation(n) => {
                d.field_bool("value", n.value.get(), false);
                d.field_label("raw", n.raw.get(), false);
            }
            Node::NullLiteralTypeAnnotation(_) => {}
            Node::SymbolTypeAnnotation(_) => {}
            Node::AnyTypeAnnotation(_) => {}
            Node::MixedTypeAnnotation(_) => {}
            Node::BigIntTypeAnnotation(_) => {}
            Node::VoidTypeAnnotation(_) => {}
            Node::NeverTypeAnnotation(_) => {}
            Node::UnknownTypeAnnotation(_) => {}
            Node::UndefinedTypeAnnotation(_) => {}
            Node::FunctionTypeAnnotation(n) => {
                d.field_list("params", n.params, false);
                d.field_node("this", n.this, false);
                d.field_node("returnType", Some(n.return_type), false);
                d.field_node("rest", n.rest, false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::HookTypeAnnotation(n) => {
                d.field_list("params", n.params, false);
                d.field_node("returnType", Some(n.return_type), false);
                d.field_node("rest", n.rest, false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::FunctionTypeParam(n) => {
                d.field_node("name", n.name, false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
                d.field_bool("optional", n.optional.get(), false);
            }
            Node::ComponentTypeAnnotation(n) => {
                d.field_list("params", n.params, false);
                d.field_node("rest", n.rest, false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_node("rendersType", n.renders_type, false);
            }
            Node::ComponentTypeParameter(n) => {
                d.field_node("name", n.name, false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
                d.field_bool("optional", n.optional.get(), false);
            }
            Node::NullableTypeAnnotation(n) => {
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::QualifiedTypeIdentifier(n) => {
                d.field_node("qualification", Some(n.qualification), false);
                d.field_node("id", Some(n.id), false);
            }
            Node::TypeofTypeAnnotation(n) => {
                d.field_node("argument", Some(n.argument), false);
                d.field_node("typeArguments", n.type_arguments, true);
            }
            Node::KeyofTypeAnnotation(n) => {
                d.field_node("argument", Some(n.argument), false);
            }
            Node::TypeOperator(n) => {
                d.field_label("operator", n.operator.get(), false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::QualifiedTypeofIdentifier(n) => {
                d.field_node("qualification", Some(n.qualification), false);
                d.field_node("id", Some(n.id), false);
            }
            Node::TupleTypeAnnotation(n) => {
                d.field_list("elementTypes", n.element_types, false);
                d.field_bool("inexact", n.inexact.get(), false);
            }
            Node::TupleTypeSpreadElement(n) => {
                d.field_node("label", n.label, false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::TupleTypeLabeledElement(n) => {
                d.field_node("label", Some(n.label), false);
                d.field_node("elementType", Some(n.element_type), false);
                d.field_bool("optional", n.optional.get(), false);
                d.field_node("variance", n.variance, false);
            }
            Node::ArrayTypeAnnotation(n) => {
                d.field_node("elementType", Some(n.element_type), false);
            }
            Node::InferTypeAnnotation(n) => {
                d.field_node("typeParameter", Some(n.type_parameter), false);
            }
            Node::UnionTypeAnnotation(n) => {
                d.field_list("types", n.types, false);
            }
            Node::IntersectionTypeAnnotation(n) => {
                d.field_list("types", n.types, false);
            }
            Node::GenericTypeAnnotation(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::IndexedAccessType(n) => {
                d.field_node("objectType", Some(n.object_type), false);
                d.field_node("indexType", Some(n.index_type), false);
            }
            Node::OptionalIndexedAccessType(n) => {
                d.field_node("objectType", Some(n.object_type), false);
                d.field_node("indexType", Some(n.index_type), false);
                d.field_bool("optional", n.optional.get(), false);
            }
            Node::ConditionalTypeAnnotation(n) => {
                d.field_node("checkType", Some(n.check_type), false);
                d.field_node("extendsType", Some(n.extends_type), false);
                d.field_node("trueType", Some(n.true_type), false);
                d.field_node("falseType", Some(n.false_type), false);
            }
            Node::TypePredicate(n) => {
                d.field_node("parameterName", Some(n.parameter_name), false);
                d.field_node("typeAnnotation", n.type_annotation, false);
                d.field_label("kind", n.kind.get(), false);
            }
            Node::InterfaceTypeAnnotation(n) => {
                d.field_list("extends", n.extends, false);
                d.field_node("body", n.body, false);
            }
            Node::TypeAlias(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_node("right", Some(n.right), false);
            }
            Node::OpaqueType(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_node("impltype", Some(n.impltype), false);
                d.field_node("lowerBound", n.lower_bound, false);
                d.field_node("upperBound", n.upper_bound, false);
                d.field_node("supertype", n.supertype, false);
            }
            Node::InterfaceDeclaration(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_list("extends", n.extends, false);
                d.field_node("body", Some(n.body), false);
            }
            Node::DeclareTypeAlias(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_node("right", Some(n.right), false);
            }
            Node::DeclareOpaqueType(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_node("impltype", n.impltype, false);
                d.field_node("lowerBound", n.lower_bound, false);
                d.field_node("upperBound", n.upper_bound, false);
                d.field_node("supertype", n.supertype, false);
            }
            Node::DeclareInterface(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_list("extends", n.extends, false);
                d.field_node("body", Some(n.body), false);
            }
            Node::DeclareClass(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_list("extends", n.extends, false);
                d.field_list("implements", n.implements, false);
                d.field_list("mixins", n.mixins, false);
                d.field_node("body", Some(n.body), false);
            }
            Node::DeclareFunction(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("predicate", n.predicate, false);
            }
            Node::DeclareHook(n) => {
                d.field_node("id", Some(n.id), false);
            }
            Node::DeclareComponent(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_list("params", n.params, false);
                d.field_node("rest", n.rest, false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_node("rendersType", n.renders_type, false);
            }
            Node::DeclareVariable(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_label("kind", n.kind.get(), false);
            }
            Node::DeclareEnum(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("body", Some(n.body), false);
            }
            Node::DeclareExportDeclaration(n) => {
                d.field_node("declaration", n.declaration, false);
                d.field_list("specifiers", n.specifiers, false);
                d.field_node("source", n.source, false);
                d.field_bool("default", n.default.get(), false);
            }
            Node::DeclareExportAllDeclaration(n) => {
                d.field_node("source", Some(n.source), false);
            }
            Node::DeclareModule(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("body", Some(n.body), false);
            }
            Node::DeclareNamespace(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("body", Some(n.body), false);
            }
            Node::DeclareModuleExports(n) => {
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::InterfaceExtends(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::ClassImplements(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::TypeAnnotation(n) => {
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::ObjectTypeAnnotation(n) => {
                d.field_list("properties", n.properties, false);
                d.field_list("indexers", n.indexers, false);
                d.field_list("callProperties", n.call_properties, false);
                d.field_list("internalSlots", n.internal_slots, false);
                d.field_bool("inexact", n.inexact.get(), false);
                d.field_bool("exact", n.exact.get(), false);
            }
            Node::ObjectTypeProperty(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("value", Some(n.value), false);
                d.field_bool("method", n.method.get(), false);
                d.field_bool("optional", n.optional.get(), false);
                d.field_bool("static", n.r#static.get(), false);
                d.field_bool("proto", n.proto.get(), false);
                d.field_node("variance", n.variance, false);
                d.field_label("kind", n.kind.get(), false);
            }
            Node::ObjectTypeSpreadProperty(n) => {
                d.field_node("argument", Some(n.argument), false);
            }
            Node::ObjectTypeInternalSlot(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("value", Some(n.value), false);
                d.field_bool("optional", n.optional.get(), false);
                d.field_bool("static", n.r#static.get(), false);
                d.field_bool("method", n.method.get(), false);
            }
            Node::ObjectTypeCallProperty(n) => {
                d.field_node("value", Some(n.value), false);
                d.field_bool("static", n.r#static.get(), false);
            }
            Node::ObjectTypeIndexer(n) => {
                d.field_node("id", n.id, false);
                d.field_node("key", Some(n.key), false);
                d.field_node("value", Some(n.value), false);
                d.field_bool("static", n.r#static.get(), false);
                d.field_node("variance", n.variance, false);
            }
            Node::ObjectTypeMappedTypeProperty(n) => {
                d.field_node("keyTparam", Some(n.key_tparam), false);
                d.field_node("propType", Some(n.prop_type), false);
                d.field_node("sourceType", Some(n.source_type), false);
                d.field_node("variance", n.variance, false);
                d.field_label("optional", n.optional.get(), false);
            }
            Node::Variance(n) => {
                d.field_label("kind", n.kind.get(), false);
            }
            Node::TypeParameterDeclaration(n) => {
                d.field_list("params", n.params, false);
            }
            Node::TypeParameter(n) => {
                d.field_label("name", n.name.get(), false);
                d.field_bool("const", n.r#const.get(), true);
                d.field_node("bound", n.bound, false);
                d.field_node("variance", n.variance, false);
                d.field_node("default", n.default, false);
                d.field_bool("usesExtendsBound", n.uses_extends_bound.get(), true);
            }
            Node::TypeParameterInstantiation(n) => {
                d.field_list("params", n.params, false);
            }
            Node::TypeCastExpression(n) => {
                d.field_node("expression", Some(n.expression), false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::AsExpression(n) => {
                d.field_node("expression", Some(n.expression), false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::AsConstExpression(n) => {
                d.field_node("expression", Some(n.expression), false);
            }
            Node::InferredPredicate(_) => {}
            Node::DeclaredPredicate(n) => {
                d.field_node("value", Some(n.value), false);
            }
            Node::EnumDeclaration(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("body", Some(n.body), false);
            }
            Node::EnumStringBody(n) => {
                d.field_list("members", n.members, false);
                d.field_bool("explicitType", n.explicit_type.get(), false);
                d.field_bool("hasUnknownMembers", n.has_unknown_members.get(), false);
            }
            Node::EnumNumberBody(n) => {
                d.field_list("members", n.members, false);
                d.field_bool("explicitType", n.explicit_type.get(), false);
                d.field_bool("hasUnknownMembers", n.has_unknown_members.get(), false);
            }
            Node::EnumBigIntBody(n) => {
                d.field_list("members", n.members, false);
                d.field_bool("explicitType", n.explicit_type.get(), false);
                d.field_bool("hasUnknownMembers", n.has_unknown_members.get(), false);
            }
            Node::EnumBooleanBody(n) => {
                d.field_list("members", n.members, false);
                d.field_bool("explicitType", n.explicit_type.get(), false);
                d.field_bool("hasUnknownMembers", n.has_unknown_members.get(), false);
            }
            Node::EnumSymbolBody(n) => {
                d.field_list("members", n.members, false);
                d.field_bool("hasUnknownMembers", n.has_unknown_members.get(), false);
            }
            Node::EnumDefaultedMember(n) => {
                d.field_node("id", Some(n.id), false);
            }
            Node::EnumStringMember(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("init", Some(n.init), false);
            }
            Node::EnumNumberMember(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("init", Some(n.init), false);
            }
            Node::EnumBigIntMember(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("init", Some(n.init), false);
            }
            Node::EnumBooleanMember(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("init", Some(n.init), false);
            }
            Node::ComponentParameter(n) => {
                d.field_node("name", Some(n.name), false);
                d.field_node("local", Some(n.local), false);
                d.field_bool("shorthand", n.shorthand.get(), false);
            }
            Node::RecordDeclaration(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_list("implements", n.implements, false);
                d.field_node("body", Some(n.body), false);
            }
            Node::RecordDeclarationImplements(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeArguments", n.type_arguments, false);
            }
            Node::RecordDeclarationBody(n) => {
                d.field_list("elements", n.elements, false);
            }
            Node::RecordDeclarationProperty(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
                d.field_node("defaultValue", n.default_value, false);
            }
            Node::RecordDeclarationStaticProperty(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
                d.field_node("value", Some(n.value), false);
            }
            Node::RecordExpression(n) => {
                d.field_node("recordConstructor", Some(n.record_constructor), false);
                d.field_node("typeArguments", n.type_arguments, false);
                d.field_node("properties", Some(n.properties), false);
            }
            Node::RecordExpressionProperties(n) => {
                d.field_list("properties", n.properties, false);
            }
            Node::TSTypeAnnotation(n) => {
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::TSAnyKeyword(_) => {}
            Node::TSNumberKeyword(_) => {}
            Node::TSBooleanKeyword(_) => {}
            Node::TSStringKeyword(_) => {}
            Node::TSSymbolKeyword(_) => {}
            Node::TSVoidKeyword(_) => {}
            Node::TSUndefinedKeyword(_) => {}
            Node::TSUnknownKeyword(_) => {}
            Node::TSNeverKeyword(_) => {}
            Node::TSBigIntKeyword(_) => {}
            Node::TSThisType(_) => {}
            Node::TSLiteralType(n) => {
                d.field_node("literal", Some(n.literal), false);
            }
            Node::TSIndexedAccessType(n) => {
                d.field_node("objectType", Some(n.object_type), false);
                d.field_node("indexType", Some(n.index_type), false);
            }
            Node::TSArrayType(n) => {
                d.field_node("elementType", Some(n.element_type), false);
            }
            Node::TSTypeReference(n) => {
                d.field_node("typeName", Some(n.type_name), false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::TSQualifiedName(n) => {
                d.field_node("left", Some(n.left), false);
                d.field_node("right", n.right, false);
            }
            Node::TSFunctionType(n) => {
                d.field_list("params", n.params, false);
                d.field_node("returnType", Some(n.return_type), false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::TSConstructorType(n) => {
                d.field_list("params", n.params, false);
                d.field_node("returnType", Some(n.return_type), false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::TSTypePredicate(n) => {
                d.field_node("parameterName", Some(n.parameter_name), false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::TSTupleType(n) => {
                d.field_list("elementTypes", n.element_types, false);
            }
            Node::TSTypeAssertion(n) => {
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
                d.field_node("expression", Some(n.expression), false);
            }
            Node::TSAsExpression(n) => {
                d.field_node("expression", Some(n.expression), false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::TSParameterProperty(n) => {
                d.field_node("parameter", Some(n.parameter), false);
                d.field_label("accessibility", n.accessibility.get(), false);
                d.field_bool("readonly", n.readonly.get(), false);
                d.field_bool("static", n.r#static.get(), false);
                d.field_bool("export", n.export.get(), false);
            }
            Node::TSTypeAliasDeclaration(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("typeParameters", n.type_parameters, false);
                d.field_node("typeAnnotation", Some(n.type_annotation), false);
            }
            Node::TSInterfaceDeclaration(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("body", Some(n.body), false);
                d.field_list("extends", n.extends, false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::TSInterfaceHeritage(n) => {
                d.field_node("expression", Some(n.expression), false);
                d.field_node("typeParameters", n.type_parameters, false);
            }
            Node::TSInterfaceBody(n) => {
                d.field_list("body", n.body, false);
            }
            Node::TSEnumDeclaration(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_list("members", n.members, false);
            }
            Node::TSEnumMember(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("initializer", n.initializer, false);
            }
            Node::TSModuleDeclaration(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("body", Some(n.body), false);
            }
            Node::TSModuleBlock(n) => {
                d.field_list("body", n.body, false);
            }
            Node::TSModuleMember(n) => {
                d.field_node("id", Some(n.id), false);
                d.field_node("initializer", n.initializer, false);
            }
            Node::TSTypeParameterDeclaration(n) => {
                d.field_list("params", n.params, false);
            }
            Node::TSTypeParameter(n) => {
                d.field_node("name", Some(n.name), false);
                d.field_node("constraint", n.constraint, false);
                d.field_node("default", n.default, false);
            }
            Node::TSTypeParameterInstantiation(n) => {
                d.field_list("params", n.params, false);
            }
            Node::TSUnionType(n) => {
                d.field_list("types", n.types, false);
            }
            Node::TSIntersectionType(n) => {
                d.field_list("types", n.types, false);
            }
            Node::TSTypeQuery(n) => {
                d.field_node("exprName", Some(n.expr_name), false);
            }
            Node::TSConditionalType(n) => {
                d.field_node("checkType", Some(n.check_type), false);
                d.field_node("extendsType", Some(n.extends_type), false);
                d.field_node("trueType", Some(n.true_type), false);
                d.field_node("falseType", Some(n.false_type), false);
            }
            Node::TSTypeLiteral(n) => {
                d.field_list("members", n.members, false);
            }
            Node::TSPropertySignature(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_node("typeAnnotation", n.type_annotation, false);
                d.field_node("initializer", n.initializer, false);
                d.field_bool("optional", n.optional.get(), false);
                d.field_bool("computed", n.computed.get(), false);
                d.field_bool("readonly", n.readonly.get(), false);
                d.field_bool("static", n.r#static.get(), false);
                d.field_bool("export", n.export.get(), false);
            }
            Node::TSMethodSignature(n) => {
                d.field_node("key", Some(n.key), false);
                d.field_list("params", n.params, false);
                d.field_node("returnType", n.return_type, false);
                d.field_bool("computed", n.computed.get(), false);
            }
            Node::TSIndexSignature(n) => {
                d.field_list("parameters", n.parameters, false);
                d.field_node("typeAnnotation", n.type_annotation, false);
            }
            Node::TSCallSignatureDeclaration(n) => {
                d.field_list("params", n.params, false);
                d.field_node("returnType", n.return_type, false);
            }
            Node::TSModifiers(n) => {
                d.field_label("accessibility", n.accessibility.get(), false);
                d.field_bool("readonly", n.readonly.get(), false);
            }
            Node::CoverEmptyArgs(_) => {}
            Node::CoverTrailingComma(_) => {}
            Node::CoverInitializer(n) => {
                d.field_node("init", Some(n.init), false);
            }
            Node::CoverRestElement(n) => {
                d.field_node("rest", Some(n.rest), false);
            }
            Node::CoverTypedIdentifier(n) => {
                d.field_node("left", Some(n.left), false);
                d.field_node("right", n.right, false);
                d.field_bool("optional", n.optional.get(), false);
            }
            Node::SHBuiltin(_) => {}
            Node::ImplicitCheckedCast(n) => {
                d.field_node("argument", Some(n.argument), false);
            }
        }
    }
}

/// Per-kind node builders: clone a node with (optionally) one
/// structural-child field changed. The rebuild primitive used by
/// `Node::visit_children_mut`.
pub mod builder {
    use std::cell::Cell;
    use super::*;
    use crate::node_child::NodeChild;
    use crate::visitor::TransformResult;

    /// One builder per node kind; clone-with-one-field-changed.
    #[derive(Debug)]
    pub enum Builder<'gc> {
        /// Builder for [`super::Empty`].
        Empty(self::Empty<'gc>),
        /// Builder for [`super::Metadata`].
        Metadata(self::Metadata<'gc>),
        /// Builder for [`super::Program`].
        Program(self::Program<'gc>),
        /// Builder for [`super::FunctionExpression`].
        FunctionExpression(self::FunctionExpression<'gc>),
        /// Builder for [`super::ArrowFunctionExpression`].
        ArrowFunctionExpression(self::ArrowFunctionExpression<'gc>),
        /// Builder for [`super::FunctionDeclaration`].
        FunctionDeclaration(self::FunctionDeclaration<'gc>),
        /// Builder for [`super::ComponentDeclaration`].
        ComponentDeclaration(self::ComponentDeclaration<'gc>),
        /// Builder for [`super::HookDeclaration`].
        HookDeclaration(self::HookDeclaration<'gc>),
        /// Builder for [`super::MatchStatement`].
        MatchStatement(self::MatchStatement<'gc>),
        /// Builder for [`super::WhileStatement`].
        WhileStatement(self::WhileStatement<'gc>),
        /// Builder for [`super::DoWhileStatement`].
        DoWhileStatement(self::DoWhileStatement<'gc>),
        /// Builder for [`super::ForInStatement`].
        ForInStatement(self::ForInStatement<'gc>),
        /// Builder for [`super::ForOfStatement`].
        ForOfStatement(self::ForOfStatement<'gc>),
        /// Builder for [`super::ForStatement`].
        ForStatement(self::ForStatement<'gc>),
        /// Builder for [`super::DebuggerStatement`].
        DebuggerStatement(self::DebuggerStatement<'gc>),
        /// Builder for [`super::EmptyStatement`].
        EmptyStatement(self::EmptyStatement<'gc>),
        /// Builder for [`super::BlockStatement`].
        BlockStatement(self::BlockStatement<'gc>),
        /// Builder for [`super::StaticBlock`].
        StaticBlock(self::StaticBlock<'gc>),
        /// Builder for [`super::BreakStatement`].
        BreakStatement(self::BreakStatement<'gc>),
        /// Builder for [`super::ContinueStatement`].
        ContinueStatement(self::ContinueStatement<'gc>),
        /// Builder for [`super::ThrowStatement`].
        ThrowStatement(self::ThrowStatement<'gc>),
        /// Builder for [`super::ReturnStatement`].
        ReturnStatement(self::ReturnStatement<'gc>),
        /// Builder for [`super::WithStatement`].
        WithStatement(self::WithStatement<'gc>),
        /// Builder for [`super::SwitchStatement`].
        SwitchStatement(self::SwitchStatement<'gc>),
        /// Builder for [`super::LabeledStatement`].
        LabeledStatement(self::LabeledStatement<'gc>),
        /// Builder for [`super::ExpressionStatement`].
        ExpressionStatement(self::ExpressionStatement<'gc>),
        /// Builder for [`super::TryStatement`].
        TryStatement(self::TryStatement<'gc>),
        /// Builder for [`super::IfStatement`].
        IfStatement(self::IfStatement<'gc>),
        /// Builder for [`super::NullLiteral`].
        NullLiteral(self::NullLiteral<'gc>),
        /// Builder for [`super::BooleanLiteral`].
        BooleanLiteral(self::BooleanLiteral<'gc>),
        /// Builder for [`super::StringLiteral`].
        StringLiteral(self::StringLiteral<'gc>),
        /// Builder for [`super::NumericLiteral`].
        NumericLiteral(self::NumericLiteral<'gc>),
        /// Builder for [`super::RegExpLiteral`].
        RegExpLiteral(self::RegExpLiteral<'gc>),
        /// Builder for [`super::BigIntLiteral`].
        BigIntLiteral(self::BigIntLiteral<'gc>),
        /// Builder for [`super::ThisExpression`].
        ThisExpression(self::ThisExpression<'gc>),
        /// Builder for [`super::Super`].
        Super(self::Super<'gc>),
        /// Builder for [`super::SequenceExpression`].
        SequenceExpression(self::SequenceExpression<'gc>),
        /// Builder for [`super::ObjectExpression`].
        ObjectExpression(self::ObjectExpression<'gc>),
        /// Builder for [`super::ArrayExpression`].
        ArrayExpression(self::ArrayExpression<'gc>),
        /// Builder for [`super::SpreadElement`].
        SpreadElement(self::SpreadElement<'gc>),
        /// Builder for [`super::NewExpression`].
        NewExpression(self::NewExpression<'gc>),
        /// Builder for [`super::YieldExpression`].
        YieldExpression(self::YieldExpression<'gc>),
        /// Builder for [`super::AwaitExpression`].
        AwaitExpression(self::AwaitExpression<'gc>),
        /// Builder for [`super::ImportExpression`].
        ImportExpression(self::ImportExpression<'gc>),
        /// Builder for [`super::CallExpression`].
        CallExpression(self::CallExpression<'gc>),
        /// Builder for [`super::OptionalCallExpression`].
        OptionalCallExpression(self::OptionalCallExpression<'gc>),
        /// Builder for [`super::AssignmentExpression`].
        AssignmentExpression(self::AssignmentExpression<'gc>),
        /// Builder for [`super::UnaryExpression`].
        UnaryExpression(self::UnaryExpression<'gc>),
        /// Builder for [`super::UpdateExpression`].
        UpdateExpression(self::UpdateExpression<'gc>),
        /// Builder for [`super::MemberExpression`].
        MemberExpression(self::MemberExpression<'gc>),
        /// Builder for [`super::OptionalMemberExpression`].
        OptionalMemberExpression(self::OptionalMemberExpression<'gc>),
        /// Builder for [`super::LogicalExpression`].
        LogicalExpression(self::LogicalExpression<'gc>),
        /// Builder for [`super::ConditionalExpression`].
        ConditionalExpression(self::ConditionalExpression<'gc>),
        /// Builder for [`super::BinaryExpression`].
        BinaryExpression(self::BinaryExpression<'gc>),
        /// Builder for [`super::Directive`].
        Directive(self::Directive<'gc>),
        /// Builder for [`super::DirectiveLiteral`].
        DirectiveLiteral(self::DirectiveLiteral<'gc>),
        /// Builder for [`super::Identifier`].
        Identifier(self::Identifier<'gc>),
        /// Builder for [`super::PrivateName`].
        PrivateName(self::PrivateName<'gc>),
        /// Builder for [`super::MetaProperty`].
        MetaProperty(self::MetaProperty<'gc>),
        /// Builder for [`super::SwitchCase`].
        SwitchCase(self::SwitchCase<'gc>),
        /// Builder for [`super::CatchClause`].
        CatchClause(self::CatchClause<'gc>),
        /// Builder for [`super::VariableDeclarator`].
        VariableDeclarator(self::VariableDeclarator<'gc>),
        /// Builder for [`super::VariableDeclaration`].
        VariableDeclaration(self::VariableDeclaration<'gc>),
        /// Builder for [`super::TemplateLiteral`].
        TemplateLiteral(self::TemplateLiteral<'gc>),
        /// Builder for [`super::TaggedTemplateExpression`].
        TaggedTemplateExpression(self::TaggedTemplateExpression<'gc>),
        /// Builder for [`super::TemplateElement`].
        TemplateElement(self::TemplateElement<'gc>),
        /// Builder for [`super::Property`].
        Property(self::Property<'gc>),
        /// Builder for [`super::Decorator`].
        Decorator(self::Decorator<'gc>),
        /// Builder for [`super::ClassDeclaration`].
        ClassDeclaration(self::ClassDeclaration<'gc>),
        /// Builder for [`super::ClassExpression`].
        ClassExpression(self::ClassExpression<'gc>),
        /// Builder for [`super::ClassBody`].
        ClassBody(self::ClassBody<'gc>),
        /// Builder for [`super::ClassProperty`].
        ClassProperty(self::ClassProperty<'gc>),
        /// Builder for [`super::ClassPrivateProperty`].
        ClassPrivateProperty(self::ClassPrivateProperty<'gc>),
        /// Builder for [`super::MethodDefinition`].
        MethodDefinition(self::MethodDefinition<'gc>),
        /// Builder for [`super::ImportDeclaration`].
        ImportDeclaration(self::ImportDeclaration<'gc>),
        /// Builder for [`super::ImportSpecifier`].
        ImportSpecifier(self::ImportSpecifier<'gc>),
        /// Builder for [`super::ImportDefaultSpecifier`].
        ImportDefaultSpecifier(self::ImportDefaultSpecifier<'gc>),
        /// Builder for [`super::ImportNamespaceSpecifier`].
        ImportNamespaceSpecifier(self::ImportNamespaceSpecifier<'gc>),
        /// Builder for [`super::ImportAttribute`].
        ImportAttribute(self::ImportAttribute<'gc>),
        /// Builder for [`super::ExportNamedDeclaration`].
        ExportNamedDeclaration(self::ExportNamedDeclaration<'gc>),
        /// Builder for [`super::ExportSpecifier`].
        ExportSpecifier(self::ExportSpecifier<'gc>),
        /// Builder for [`super::ExportNamespaceSpecifier`].
        ExportNamespaceSpecifier(self::ExportNamespaceSpecifier<'gc>),
        /// Builder for [`super::ExportDefaultDeclaration`].
        ExportDefaultDeclaration(self::ExportDefaultDeclaration<'gc>),
        /// Builder for [`super::ExportAllDeclaration`].
        ExportAllDeclaration(self::ExportAllDeclaration<'gc>),
        /// Builder for [`super::ObjectPattern`].
        ObjectPattern(self::ObjectPattern<'gc>),
        /// Builder for [`super::ArrayPattern`].
        ArrayPattern(self::ArrayPattern<'gc>),
        /// Builder for [`super::RestElement`].
        RestElement(self::RestElement<'gc>),
        /// Builder for [`super::AssignmentPattern`].
        AssignmentPattern(self::AssignmentPattern<'gc>),
        /// Builder for [`super::MatchStatementCase`].
        MatchStatementCase(self::MatchStatementCase<'gc>),
        /// Builder for [`super::MatchExpression`].
        MatchExpression(self::MatchExpression<'gc>),
        /// Builder for [`super::MatchExpressionCase`].
        MatchExpressionCase(self::MatchExpressionCase<'gc>),
        /// Builder for [`super::MatchWildcardPattern`].
        MatchWildcardPattern(self::MatchWildcardPattern<'gc>),
        /// Builder for [`super::MatchLiteralPattern`].
        MatchLiteralPattern(self::MatchLiteralPattern<'gc>),
        /// Builder for [`super::MatchUnaryPattern`].
        MatchUnaryPattern(self::MatchUnaryPattern<'gc>),
        /// Builder for [`super::MatchIdentifierPattern`].
        MatchIdentifierPattern(self::MatchIdentifierPattern<'gc>),
        /// Builder for [`super::MatchBindingPattern`].
        MatchBindingPattern(self::MatchBindingPattern<'gc>),
        /// Builder for [`super::MatchObjectPattern`].
        MatchObjectPattern(self::MatchObjectPattern<'gc>),
        /// Builder for [`super::MatchArrayPattern`].
        MatchArrayPattern(self::MatchArrayPattern<'gc>),
        /// Builder for [`super::MatchOrPattern`].
        MatchOrPattern(self::MatchOrPattern<'gc>),
        /// Builder for [`super::MatchAsPattern`].
        MatchAsPattern(self::MatchAsPattern<'gc>),
        /// Builder for [`super::MatchMemberPattern`].
        MatchMemberPattern(self::MatchMemberPattern<'gc>),
        /// Builder for [`super::MatchInstancePattern`].
        MatchInstancePattern(self::MatchInstancePattern<'gc>),
        /// Builder for [`super::MatchObjectPatternProperty`].
        MatchObjectPatternProperty(self::MatchObjectPatternProperty<'gc>),
        /// Builder for [`super::MatchInstanceObjectPattern`].
        MatchInstanceObjectPattern(self::MatchInstanceObjectPattern<'gc>),
        /// Builder for [`super::MatchRestPattern`].
        MatchRestPattern(self::MatchRestPattern<'gc>),
        /// Builder for [`super::JSXIdentifier`].
        JSXIdentifier(self::JSXIdentifier<'gc>),
        /// Builder for [`super::JSXMemberExpression`].
        JSXMemberExpression(self::JSXMemberExpression<'gc>),
        /// Builder for [`super::JSXNamespacedName`].
        JSXNamespacedName(self::JSXNamespacedName<'gc>),
        /// Builder for [`super::JSXEmptyExpression`].
        JSXEmptyExpression(self::JSXEmptyExpression<'gc>),
        /// Builder for [`super::JSXExpressionContainer`].
        JSXExpressionContainer(self::JSXExpressionContainer<'gc>),
        /// Builder for [`super::JSXSpreadChild`].
        JSXSpreadChild(self::JSXSpreadChild<'gc>),
        /// Builder for [`super::JSXOpeningElement`].
        JSXOpeningElement(self::JSXOpeningElement<'gc>),
        /// Builder for [`super::JSXClosingElement`].
        JSXClosingElement(self::JSXClosingElement<'gc>),
        /// Builder for [`super::JSXAttribute`].
        JSXAttribute(self::JSXAttribute<'gc>),
        /// Builder for [`super::JSXSpreadAttribute`].
        JSXSpreadAttribute(self::JSXSpreadAttribute<'gc>),
        /// Builder for [`super::JSXStringLiteral`].
        JSXStringLiteral(self::JSXStringLiteral<'gc>),
        /// Builder for [`super::JSXText`].
        JSXText(self::JSXText<'gc>),
        /// Builder for [`super::JSXElement`].
        JSXElement(self::JSXElement<'gc>),
        /// Builder for [`super::JSXFragment`].
        JSXFragment(self::JSXFragment<'gc>),
        /// Builder for [`super::JSXOpeningFragment`].
        JSXOpeningFragment(self::JSXOpeningFragment<'gc>),
        /// Builder for [`super::JSXClosingFragment`].
        JSXClosingFragment(self::JSXClosingFragment<'gc>),
        /// Builder for [`super::ExistsTypeAnnotation`].
        ExistsTypeAnnotation(self::ExistsTypeAnnotation<'gc>),
        /// Builder for [`super::EmptyTypeAnnotation`].
        EmptyTypeAnnotation(self::EmptyTypeAnnotation<'gc>),
        /// Builder for [`super::StringTypeAnnotation`].
        StringTypeAnnotation(self::StringTypeAnnotation<'gc>),
        /// Builder for [`super::NumberTypeAnnotation`].
        NumberTypeAnnotation(self::NumberTypeAnnotation<'gc>),
        /// Builder for [`super::StringLiteralTypeAnnotation`].
        StringLiteralTypeAnnotation(self::StringLiteralTypeAnnotation<'gc>),
        /// Builder for [`super::NumberLiteralTypeAnnotation`].
        NumberLiteralTypeAnnotation(self::NumberLiteralTypeAnnotation<'gc>),
        /// Builder for [`super::BigIntLiteralTypeAnnotation`].
        BigIntLiteralTypeAnnotation(self::BigIntLiteralTypeAnnotation<'gc>),
        /// Builder for [`super::BooleanTypeAnnotation`].
        BooleanTypeAnnotation(self::BooleanTypeAnnotation<'gc>),
        /// Builder for [`super::BooleanLiteralTypeAnnotation`].
        BooleanLiteralTypeAnnotation(self::BooleanLiteralTypeAnnotation<'gc>),
        /// Builder for [`super::NullLiteralTypeAnnotation`].
        NullLiteralTypeAnnotation(self::NullLiteralTypeAnnotation<'gc>),
        /// Builder for [`super::SymbolTypeAnnotation`].
        SymbolTypeAnnotation(self::SymbolTypeAnnotation<'gc>),
        /// Builder for [`super::AnyTypeAnnotation`].
        AnyTypeAnnotation(self::AnyTypeAnnotation<'gc>),
        /// Builder for [`super::MixedTypeAnnotation`].
        MixedTypeAnnotation(self::MixedTypeAnnotation<'gc>),
        /// Builder for [`super::BigIntTypeAnnotation`].
        BigIntTypeAnnotation(self::BigIntTypeAnnotation<'gc>),
        /// Builder for [`super::VoidTypeAnnotation`].
        VoidTypeAnnotation(self::VoidTypeAnnotation<'gc>),
        /// Builder for [`super::NeverTypeAnnotation`].
        NeverTypeAnnotation(self::NeverTypeAnnotation<'gc>),
        /// Builder for [`super::UnknownTypeAnnotation`].
        UnknownTypeAnnotation(self::UnknownTypeAnnotation<'gc>),
        /// Builder for [`super::UndefinedTypeAnnotation`].
        UndefinedTypeAnnotation(self::UndefinedTypeAnnotation<'gc>),
        /// Builder for [`super::FunctionTypeAnnotation`].
        FunctionTypeAnnotation(self::FunctionTypeAnnotation<'gc>),
        /// Builder for [`super::HookTypeAnnotation`].
        HookTypeAnnotation(self::HookTypeAnnotation<'gc>),
        /// Builder for [`super::FunctionTypeParam`].
        FunctionTypeParam(self::FunctionTypeParam<'gc>),
        /// Builder for [`super::ComponentTypeAnnotation`].
        ComponentTypeAnnotation(self::ComponentTypeAnnotation<'gc>),
        /// Builder for [`super::ComponentTypeParameter`].
        ComponentTypeParameter(self::ComponentTypeParameter<'gc>),
        /// Builder for [`super::NullableTypeAnnotation`].
        NullableTypeAnnotation(self::NullableTypeAnnotation<'gc>),
        /// Builder for [`super::QualifiedTypeIdentifier`].
        QualifiedTypeIdentifier(self::QualifiedTypeIdentifier<'gc>),
        /// Builder for [`super::TypeofTypeAnnotation`].
        TypeofTypeAnnotation(self::TypeofTypeAnnotation<'gc>),
        /// Builder for [`super::KeyofTypeAnnotation`].
        KeyofTypeAnnotation(self::KeyofTypeAnnotation<'gc>),
        /// Builder for [`super::TypeOperator`].
        TypeOperator(self::TypeOperator<'gc>),
        /// Builder for [`super::QualifiedTypeofIdentifier`].
        QualifiedTypeofIdentifier(self::QualifiedTypeofIdentifier<'gc>),
        /// Builder for [`super::TupleTypeAnnotation`].
        TupleTypeAnnotation(self::TupleTypeAnnotation<'gc>),
        /// Builder for [`super::TupleTypeSpreadElement`].
        TupleTypeSpreadElement(self::TupleTypeSpreadElement<'gc>),
        /// Builder for [`super::TupleTypeLabeledElement`].
        TupleTypeLabeledElement(self::TupleTypeLabeledElement<'gc>),
        /// Builder for [`super::ArrayTypeAnnotation`].
        ArrayTypeAnnotation(self::ArrayTypeAnnotation<'gc>),
        /// Builder for [`super::InferTypeAnnotation`].
        InferTypeAnnotation(self::InferTypeAnnotation<'gc>),
        /// Builder for [`super::UnionTypeAnnotation`].
        UnionTypeAnnotation(self::UnionTypeAnnotation<'gc>),
        /// Builder for [`super::IntersectionTypeAnnotation`].
        IntersectionTypeAnnotation(self::IntersectionTypeAnnotation<'gc>),
        /// Builder for [`super::GenericTypeAnnotation`].
        GenericTypeAnnotation(self::GenericTypeAnnotation<'gc>),
        /// Builder for [`super::IndexedAccessType`].
        IndexedAccessType(self::IndexedAccessType<'gc>),
        /// Builder for [`super::OptionalIndexedAccessType`].
        OptionalIndexedAccessType(self::OptionalIndexedAccessType<'gc>),
        /// Builder for [`super::ConditionalTypeAnnotation`].
        ConditionalTypeAnnotation(self::ConditionalTypeAnnotation<'gc>),
        /// Builder for [`super::TypePredicate`].
        TypePredicate(self::TypePredicate<'gc>),
        /// Builder for [`super::InterfaceTypeAnnotation`].
        InterfaceTypeAnnotation(self::InterfaceTypeAnnotation<'gc>),
        /// Builder for [`super::TypeAlias`].
        TypeAlias(self::TypeAlias<'gc>),
        /// Builder for [`super::OpaqueType`].
        OpaqueType(self::OpaqueType<'gc>),
        /// Builder for [`super::InterfaceDeclaration`].
        InterfaceDeclaration(self::InterfaceDeclaration<'gc>),
        /// Builder for [`super::DeclareTypeAlias`].
        DeclareTypeAlias(self::DeclareTypeAlias<'gc>),
        /// Builder for [`super::DeclareOpaqueType`].
        DeclareOpaqueType(self::DeclareOpaqueType<'gc>),
        /// Builder for [`super::DeclareInterface`].
        DeclareInterface(self::DeclareInterface<'gc>),
        /// Builder for [`super::DeclareClass`].
        DeclareClass(self::DeclareClass<'gc>),
        /// Builder for [`super::DeclareFunction`].
        DeclareFunction(self::DeclareFunction<'gc>),
        /// Builder for [`super::DeclareHook`].
        DeclareHook(self::DeclareHook<'gc>),
        /// Builder for [`super::DeclareComponent`].
        DeclareComponent(self::DeclareComponent<'gc>),
        /// Builder for [`super::DeclareVariable`].
        DeclareVariable(self::DeclareVariable<'gc>),
        /// Builder for [`super::DeclareEnum`].
        DeclareEnum(self::DeclareEnum<'gc>),
        /// Builder for [`super::DeclareExportDeclaration`].
        DeclareExportDeclaration(self::DeclareExportDeclaration<'gc>),
        /// Builder for [`super::DeclareExportAllDeclaration`].
        DeclareExportAllDeclaration(self::DeclareExportAllDeclaration<'gc>),
        /// Builder for [`super::DeclareModule`].
        DeclareModule(self::DeclareModule<'gc>),
        /// Builder for [`super::DeclareNamespace`].
        DeclareNamespace(self::DeclareNamespace<'gc>),
        /// Builder for [`super::DeclareModuleExports`].
        DeclareModuleExports(self::DeclareModuleExports<'gc>),
        /// Builder for [`super::InterfaceExtends`].
        InterfaceExtends(self::InterfaceExtends<'gc>),
        /// Builder for [`super::ClassImplements`].
        ClassImplements(self::ClassImplements<'gc>),
        /// Builder for [`super::TypeAnnotation`].
        TypeAnnotation(self::TypeAnnotation<'gc>),
        /// Builder for [`super::ObjectTypeAnnotation`].
        ObjectTypeAnnotation(self::ObjectTypeAnnotation<'gc>),
        /// Builder for [`super::ObjectTypeProperty`].
        ObjectTypeProperty(self::ObjectTypeProperty<'gc>),
        /// Builder for [`super::ObjectTypeSpreadProperty`].
        ObjectTypeSpreadProperty(self::ObjectTypeSpreadProperty<'gc>),
        /// Builder for [`super::ObjectTypeInternalSlot`].
        ObjectTypeInternalSlot(self::ObjectTypeInternalSlot<'gc>),
        /// Builder for [`super::ObjectTypeCallProperty`].
        ObjectTypeCallProperty(self::ObjectTypeCallProperty<'gc>),
        /// Builder for [`super::ObjectTypeIndexer`].
        ObjectTypeIndexer(self::ObjectTypeIndexer<'gc>),
        /// Builder for [`super::ObjectTypeMappedTypeProperty`].
        ObjectTypeMappedTypeProperty(self::ObjectTypeMappedTypeProperty<'gc>),
        /// Builder for [`super::Variance`].
        Variance(self::Variance<'gc>),
        /// Builder for [`super::TypeParameterDeclaration`].
        TypeParameterDeclaration(self::TypeParameterDeclaration<'gc>),
        /// Builder for [`super::TypeParameter`].
        TypeParameter(self::TypeParameter<'gc>),
        /// Builder for [`super::TypeParameterInstantiation`].
        TypeParameterInstantiation(self::TypeParameterInstantiation<'gc>),
        /// Builder for [`super::TypeCastExpression`].
        TypeCastExpression(self::TypeCastExpression<'gc>),
        /// Builder for [`super::AsExpression`].
        AsExpression(self::AsExpression<'gc>),
        /// Builder for [`super::AsConstExpression`].
        AsConstExpression(self::AsConstExpression<'gc>),
        /// Builder for [`super::InferredPredicate`].
        InferredPredicate(self::InferredPredicate<'gc>),
        /// Builder for [`super::DeclaredPredicate`].
        DeclaredPredicate(self::DeclaredPredicate<'gc>),
        /// Builder for [`super::EnumDeclaration`].
        EnumDeclaration(self::EnumDeclaration<'gc>),
        /// Builder for [`super::EnumStringBody`].
        EnumStringBody(self::EnumStringBody<'gc>),
        /// Builder for [`super::EnumNumberBody`].
        EnumNumberBody(self::EnumNumberBody<'gc>),
        /// Builder for [`super::EnumBigIntBody`].
        EnumBigIntBody(self::EnumBigIntBody<'gc>),
        /// Builder for [`super::EnumBooleanBody`].
        EnumBooleanBody(self::EnumBooleanBody<'gc>),
        /// Builder for [`super::EnumSymbolBody`].
        EnumSymbolBody(self::EnumSymbolBody<'gc>),
        /// Builder for [`super::EnumDefaultedMember`].
        EnumDefaultedMember(self::EnumDefaultedMember<'gc>),
        /// Builder for [`super::EnumStringMember`].
        EnumStringMember(self::EnumStringMember<'gc>),
        /// Builder for [`super::EnumNumberMember`].
        EnumNumberMember(self::EnumNumberMember<'gc>),
        /// Builder for [`super::EnumBigIntMember`].
        EnumBigIntMember(self::EnumBigIntMember<'gc>),
        /// Builder for [`super::EnumBooleanMember`].
        EnumBooleanMember(self::EnumBooleanMember<'gc>),
        /// Builder for [`super::ComponentParameter`].
        ComponentParameter(self::ComponentParameter<'gc>),
        /// Builder for [`super::RecordDeclaration`].
        RecordDeclaration(self::RecordDeclaration<'gc>),
        /// Builder for [`super::RecordDeclarationImplements`].
        RecordDeclarationImplements(self::RecordDeclarationImplements<'gc>),
        /// Builder for [`super::RecordDeclarationBody`].
        RecordDeclarationBody(self::RecordDeclarationBody<'gc>),
        /// Builder for [`super::RecordDeclarationProperty`].
        RecordDeclarationProperty(self::RecordDeclarationProperty<'gc>),
        /// Builder for [`super::RecordDeclarationStaticProperty`].
        RecordDeclarationStaticProperty(self::RecordDeclarationStaticProperty<'gc>),
        /// Builder for [`super::RecordExpression`].
        RecordExpression(self::RecordExpression<'gc>),
        /// Builder for [`super::RecordExpressionProperties`].
        RecordExpressionProperties(self::RecordExpressionProperties<'gc>),
        /// Builder for [`super::TSTypeAnnotation`].
        TSTypeAnnotation(self::TSTypeAnnotation<'gc>),
        /// Builder for [`super::TSAnyKeyword`].
        TSAnyKeyword(self::TSAnyKeyword<'gc>),
        /// Builder for [`super::TSNumberKeyword`].
        TSNumberKeyword(self::TSNumberKeyword<'gc>),
        /// Builder for [`super::TSBooleanKeyword`].
        TSBooleanKeyword(self::TSBooleanKeyword<'gc>),
        /// Builder for [`super::TSStringKeyword`].
        TSStringKeyword(self::TSStringKeyword<'gc>),
        /// Builder for [`super::TSSymbolKeyword`].
        TSSymbolKeyword(self::TSSymbolKeyword<'gc>),
        /// Builder for [`super::TSVoidKeyword`].
        TSVoidKeyword(self::TSVoidKeyword<'gc>),
        /// Builder for [`super::TSUndefinedKeyword`].
        TSUndefinedKeyword(self::TSUndefinedKeyword<'gc>),
        /// Builder for [`super::TSUnknownKeyword`].
        TSUnknownKeyword(self::TSUnknownKeyword<'gc>),
        /// Builder for [`super::TSNeverKeyword`].
        TSNeverKeyword(self::TSNeverKeyword<'gc>),
        /// Builder for [`super::TSBigIntKeyword`].
        TSBigIntKeyword(self::TSBigIntKeyword<'gc>),
        /// Builder for [`super::TSThisType`].
        TSThisType(self::TSThisType<'gc>),
        /// Builder for [`super::TSLiteralType`].
        TSLiteralType(self::TSLiteralType<'gc>),
        /// Builder for [`super::TSIndexedAccessType`].
        TSIndexedAccessType(self::TSIndexedAccessType<'gc>),
        /// Builder for [`super::TSArrayType`].
        TSArrayType(self::TSArrayType<'gc>),
        /// Builder for [`super::TSTypeReference`].
        TSTypeReference(self::TSTypeReference<'gc>),
        /// Builder for [`super::TSQualifiedName`].
        TSQualifiedName(self::TSQualifiedName<'gc>),
        /// Builder for [`super::TSFunctionType`].
        TSFunctionType(self::TSFunctionType<'gc>),
        /// Builder for [`super::TSConstructorType`].
        TSConstructorType(self::TSConstructorType<'gc>),
        /// Builder for [`super::TSTypePredicate`].
        TSTypePredicate(self::TSTypePredicate<'gc>),
        /// Builder for [`super::TSTupleType`].
        TSTupleType(self::TSTupleType<'gc>),
        /// Builder for [`super::TSTypeAssertion`].
        TSTypeAssertion(self::TSTypeAssertion<'gc>),
        /// Builder for [`super::TSAsExpression`].
        TSAsExpression(self::TSAsExpression<'gc>),
        /// Builder for [`super::TSParameterProperty`].
        TSParameterProperty(self::TSParameterProperty<'gc>),
        /// Builder for [`super::TSTypeAliasDeclaration`].
        TSTypeAliasDeclaration(self::TSTypeAliasDeclaration<'gc>),
        /// Builder for [`super::TSInterfaceDeclaration`].
        TSInterfaceDeclaration(self::TSInterfaceDeclaration<'gc>),
        /// Builder for [`super::TSInterfaceHeritage`].
        TSInterfaceHeritage(self::TSInterfaceHeritage<'gc>),
        /// Builder for [`super::TSInterfaceBody`].
        TSInterfaceBody(self::TSInterfaceBody<'gc>),
        /// Builder for [`super::TSEnumDeclaration`].
        TSEnumDeclaration(self::TSEnumDeclaration<'gc>),
        /// Builder for [`super::TSEnumMember`].
        TSEnumMember(self::TSEnumMember<'gc>),
        /// Builder for [`super::TSModuleDeclaration`].
        TSModuleDeclaration(self::TSModuleDeclaration<'gc>),
        /// Builder for [`super::TSModuleBlock`].
        TSModuleBlock(self::TSModuleBlock<'gc>),
        /// Builder for [`super::TSModuleMember`].
        TSModuleMember(self::TSModuleMember<'gc>),
        /// Builder for [`super::TSTypeParameterDeclaration`].
        TSTypeParameterDeclaration(self::TSTypeParameterDeclaration<'gc>),
        /// Builder for [`super::TSTypeParameter`].
        TSTypeParameter(self::TSTypeParameter<'gc>),
        /// Builder for [`super::TSTypeParameterInstantiation`].
        TSTypeParameterInstantiation(self::TSTypeParameterInstantiation<'gc>),
        /// Builder for [`super::TSUnionType`].
        TSUnionType(self::TSUnionType<'gc>),
        /// Builder for [`super::TSIntersectionType`].
        TSIntersectionType(self::TSIntersectionType<'gc>),
        /// Builder for [`super::TSTypeQuery`].
        TSTypeQuery(self::TSTypeQuery<'gc>),
        /// Builder for [`super::TSConditionalType`].
        TSConditionalType(self::TSConditionalType<'gc>),
        /// Builder for [`super::TSTypeLiteral`].
        TSTypeLiteral(self::TSTypeLiteral<'gc>),
        /// Builder for [`super::TSPropertySignature`].
        TSPropertySignature(self::TSPropertySignature<'gc>),
        /// Builder for [`super::TSMethodSignature`].
        TSMethodSignature(self::TSMethodSignature<'gc>),
        /// Builder for [`super::TSIndexSignature`].
        TSIndexSignature(self::TSIndexSignature<'gc>),
        /// Builder for [`super::TSCallSignatureDeclaration`].
        TSCallSignatureDeclaration(self::TSCallSignatureDeclaration<'gc>),
        /// Builder for [`super::TSModifiers`].
        TSModifiers(self::TSModifiers<'gc>),
        /// Builder for [`super::CoverEmptyArgs`].
        CoverEmptyArgs(self::CoverEmptyArgs<'gc>),
        /// Builder for [`super::CoverTrailingComma`].
        CoverTrailingComma(self::CoverTrailingComma<'gc>),
        /// Builder for [`super::CoverInitializer`].
        CoverInitializer(self::CoverInitializer<'gc>),
        /// Builder for [`super::CoverRestElement`].
        CoverRestElement(self::CoverRestElement<'gc>),
        /// Builder for [`super::CoverTypedIdentifier`].
        CoverTypedIdentifier(self::CoverTypedIdentifier<'gc>),
        /// Builder for [`super::SHBuiltin`].
        SHBuiltin(self::SHBuiltin<'gc>),
        /// Builder for [`super::ImplicitCheckedCast`].
        ImplicitCheckedCast(self::ImplicitCheckedCast<'gc>),
    }

    impl<'gc> Builder<'gc> {
        /// Start a builder for `node`, dispatching on its kind.
        pub fn from_node(node: &'gc Node<'gc>) -> Self {
            match node {
                Node::Empty(n) => Builder::Empty(self::Empty::from_node(n)),
                Node::Metadata(n) => Builder::Metadata(self::Metadata::from_node(n)),
                Node::Program(n) => Builder::Program(self::Program::from_node(n)),
                Node::FunctionExpression(n) => Builder::FunctionExpression(self::FunctionExpression::from_node(n)),
                Node::ArrowFunctionExpression(n) => Builder::ArrowFunctionExpression(self::ArrowFunctionExpression::from_node(n)),
                Node::FunctionDeclaration(n) => Builder::FunctionDeclaration(self::FunctionDeclaration::from_node(n)),
                Node::ComponentDeclaration(n) => Builder::ComponentDeclaration(self::ComponentDeclaration::from_node(n)),
                Node::HookDeclaration(n) => Builder::HookDeclaration(self::HookDeclaration::from_node(n)),
                Node::MatchStatement(n) => Builder::MatchStatement(self::MatchStatement::from_node(n)),
                Node::WhileStatement(n) => Builder::WhileStatement(self::WhileStatement::from_node(n)),
                Node::DoWhileStatement(n) => Builder::DoWhileStatement(self::DoWhileStatement::from_node(n)),
                Node::ForInStatement(n) => Builder::ForInStatement(self::ForInStatement::from_node(n)),
                Node::ForOfStatement(n) => Builder::ForOfStatement(self::ForOfStatement::from_node(n)),
                Node::ForStatement(n) => Builder::ForStatement(self::ForStatement::from_node(n)),
                Node::DebuggerStatement(n) => Builder::DebuggerStatement(self::DebuggerStatement::from_node(n)),
                Node::EmptyStatement(n) => Builder::EmptyStatement(self::EmptyStatement::from_node(n)),
                Node::BlockStatement(n) => Builder::BlockStatement(self::BlockStatement::from_node(n)),
                Node::StaticBlock(n) => Builder::StaticBlock(self::StaticBlock::from_node(n)),
                Node::BreakStatement(n) => Builder::BreakStatement(self::BreakStatement::from_node(n)),
                Node::ContinueStatement(n) => Builder::ContinueStatement(self::ContinueStatement::from_node(n)),
                Node::ThrowStatement(n) => Builder::ThrowStatement(self::ThrowStatement::from_node(n)),
                Node::ReturnStatement(n) => Builder::ReturnStatement(self::ReturnStatement::from_node(n)),
                Node::WithStatement(n) => Builder::WithStatement(self::WithStatement::from_node(n)),
                Node::SwitchStatement(n) => Builder::SwitchStatement(self::SwitchStatement::from_node(n)),
                Node::LabeledStatement(n) => Builder::LabeledStatement(self::LabeledStatement::from_node(n)),
                Node::ExpressionStatement(n) => Builder::ExpressionStatement(self::ExpressionStatement::from_node(n)),
                Node::TryStatement(n) => Builder::TryStatement(self::TryStatement::from_node(n)),
                Node::IfStatement(n) => Builder::IfStatement(self::IfStatement::from_node(n)),
                Node::NullLiteral(n) => Builder::NullLiteral(self::NullLiteral::from_node(n)),
                Node::BooleanLiteral(n) => Builder::BooleanLiteral(self::BooleanLiteral::from_node(n)),
                Node::StringLiteral(n) => Builder::StringLiteral(self::StringLiteral::from_node(n)),
                Node::NumericLiteral(n) => Builder::NumericLiteral(self::NumericLiteral::from_node(n)),
                Node::RegExpLiteral(n) => Builder::RegExpLiteral(self::RegExpLiteral::from_node(n)),
                Node::BigIntLiteral(n) => Builder::BigIntLiteral(self::BigIntLiteral::from_node(n)),
                Node::ThisExpression(n) => Builder::ThisExpression(self::ThisExpression::from_node(n)),
                Node::Super(n) => Builder::Super(self::Super::from_node(n)),
                Node::SequenceExpression(n) => Builder::SequenceExpression(self::SequenceExpression::from_node(n)),
                Node::ObjectExpression(n) => Builder::ObjectExpression(self::ObjectExpression::from_node(n)),
                Node::ArrayExpression(n) => Builder::ArrayExpression(self::ArrayExpression::from_node(n)),
                Node::SpreadElement(n) => Builder::SpreadElement(self::SpreadElement::from_node(n)),
                Node::NewExpression(n) => Builder::NewExpression(self::NewExpression::from_node(n)),
                Node::YieldExpression(n) => Builder::YieldExpression(self::YieldExpression::from_node(n)),
                Node::AwaitExpression(n) => Builder::AwaitExpression(self::AwaitExpression::from_node(n)),
                Node::ImportExpression(n) => Builder::ImportExpression(self::ImportExpression::from_node(n)),
                Node::CallExpression(n) => Builder::CallExpression(self::CallExpression::from_node(n)),
                Node::OptionalCallExpression(n) => Builder::OptionalCallExpression(self::OptionalCallExpression::from_node(n)),
                Node::AssignmentExpression(n) => Builder::AssignmentExpression(self::AssignmentExpression::from_node(n)),
                Node::UnaryExpression(n) => Builder::UnaryExpression(self::UnaryExpression::from_node(n)),
                Node::UpdateExpression(n) => Builder::UpdateExpression(self::UpdateExpression::from_node(n)),
                Node::MemberExpression(n) => Builder::MemberExpression(self::MemberExpression::from_node(n)),
                Node::OptionalMemberExpression(n) => Builder::OptionalMemberExpression(self::OptionalMemberExpression::from_node(n)),
                Node::LogicalExpression(n) => Builder::LogicalExpression(self::LogicalExpression::from_node(n)),
                Node::ConditionalExpression(n) => Builder::ConditionalExpression(self::ConditionalExpression::from_node(n)),
                Node::BinaryExpression(n) => Builder::BinaryExpression(self::BinaryExpression::from_node(n)),
                Node::Directive(n) => Builder::Directive(self::Directive::from_node(n)),
                Node::DirectiveLiteral(n) => Builder::DirectiveLiteral(self::DirectiveLiteral::from_node(n)),
                Node::Identifier(n) => Builder::Identifier(self::Identifier::from_node(n)),
                Node::PrivateName(n) => Builder::PrivateName(self::PrivateName::from_node(n)),
                Node::MetaProperty(n) => Builder::MetaProperty(self::MetaProperty::from_node(n)),
                Node::SwitchCase(n) => Builder::SwitchCase(self::SwitchCase::from_node(n)),
                Node::CatchClause(n) => Builder::CatchClause(self::CatchClause::from_node(n)),
                Node::VariableDeclarator(n) => Builder::VariableDeclarator(self::VariableDeclarator::from_node(n)),
                Node::VariableDeclaration(n) => Builder::VariableDeclaration(self::VariableDeclaration::from_node(n)),
                Node::TemplateLiteral(n) => Builder::TemplateLiteral(self::TemplateLiteral::from_node(n)),
                Node::TaggedTemplateExpression(n) => Builder::TaggedTemplateExpression(self::TaggedTemplateExpression::from_node(n)),
                Node::TemplateElement(n) => Builder::TemplateElement(self::TemplateElement::from_node(n)),
                Node::Property(n) => Builder::Property(self::Property::from_node(n)),
                Node::Decorator(n) => Builder::Decorator(self::Decorator::from_node(n)),
                Node::ClassDeclaration(n) => Builder::ClassDeclaration(self::ClassDeclaration::from_node(n)),
                Node::ClassExpression(n) => Builder::ClassExpression(self::ClassExpression::from_node(n)),
                Node::ClassBody(n) => Builder::ClassBody(self::ClassBody::from_node(n)),
                Node::ClassProperty(n) => Builder::ClassProperty(self::ClassProperty::from_node(n)),
                Node::ClassPrivateProperty(n) => Builder::ClassPrivateProperty(self::ClassPrivateProperty::from_node(n)),
                Node::MethodDefinition(n) => Builder::MethodDefinition(self::MethodDefinition::from_node(n)),
                Node::ImportDeclaration(n) => Builder::ImportDeclaration(self::ImportDeclaration::from_node(n)),
                Node::ImportSpecifier(n) => Builder::ImportSpecifier(self::ImportSpecifier::from_node(n)),
                Node::ImportDefaultSpecifier(n) => Builder::ImportDefaultSpecifier(self::ImportDefaultSpecifier::from_node(n)),
                Node::ImportNamespaceSpecifier(n) => Builder::ImportNamespaceSpecifier(self::ImportNamespaceSpecifier::from_node(n)),
                Node::ImportAttribute(n) => Builder::ImportAttribute(self::ImportAttribute::from_node(n)),
                Node::ExportNamedDeclaration(n) => Builder::ExportNamedDeclaration(self::ExportNamedDeclaration::from_node(n)),
                Node::ExportSpecifier(n) => Builder::ExportSpecifier(self::ExportSpecifier::from_node(n)),
                Node::ExportNamespaceSpecifier(n) => Builder::ExportNamespaceSpecifier(self::ExportNamespaceSpecifier::from_node(n)),
                Node::ExportDefaultDeclaration(n) => Builder::ExportDefaultDeclaration(self::ExportDefaultDeclaration::from_node(n)),
                Node::ExportAllDeclaration(n) => Builder::ExportAllDeclaration(self::ExportAllDeclaration::from_node(n)),
                Node::ObjectPattern(n) => Builder::ObjectPattern(self::ObjectPattern::from_node(n)),
                Node::ArrayPattern(n) => Builder::ArrayPattern(self::ArrayPattern::from_node(n)),
                Node::RestElement(n) => Builder::RestElement(self::RestElement::from_node(n)),
                Node::AssignmentPattern(n) => Builder::AssignmentPattern(self::AssignmentPattern::from_node(n)),
                Node::MatchStatementCase(n) => Builder::MatchStatementCase(self::MatchStatementCase::from_node(n)),
                Node::MatchExpression(n) => Builder::MatchExpression(self::MatchExpression::from_node(n)),
                Node::MatchExpressionCase(n) => Builder::MatchExpressionCase(self::MatchExpressionCase::from_node(n)),
                Node::MatchWildcardPattern(n) => Builder::MatchWildcardPattern(self::MatchWildcardPattern::from_node(n)),
                Node::MatchLiteralPattern(n) => Builder::MatchLiteralPattern(self::MatchLiteralPattern::from_node(n)),
                Node::MatchUnaryPattern(n) => Builder::MatchUnaryPattern(self::MatchUnaryPattern::from_node(n)),
                Node::MatchIdentifierPattern(n) => Builder::MatchIdentifierPattern(self::MatchIdentifierPattern::from_node(n)),
                Node::MatchBindingPattern(n) => Builder::MatchBindingPattern(self::MatchBindingPattern::from_node(n)),
                Node::MatchObjectPattern(n) => Builder::MatchObjectPattern(self::MatchObjectPattern::from_node(n)),
                Node::MatchArrayPattern(n) => Builder::MatchArrayPattern(self::MatchArrayPattern::from_node(n)),
                Node::MatchOrPattern(n) => Builder::MatchOrPattern(self::MatchOrPattern::from_node(n)),
                Node::MatchAsPattern(n) => Builder::MatchAsPattern(self::MatchAsPattern::from_node(n)),
                Node::MatchMemberPattern(n) => Builder::MatchMemberPattern(self::MatchMemberPattern::from_node(n)),
                Node::MatchInstancePattern(n) => Builder::MatchInstancePattern(self::MatchInstancePattern::from_node(n)),
                Node::MatchObjectPatternProperty(n) => Builder::MatchObjectPatternProperty(self::MatchObjectPatternProperty::from_node(n)),
                Node::MatchInstanceObjectPattern(n) => Builder::MatchInstanceObjectPattern(self::MatchInstanceObjectPattern::from_node(n)),
                Node::MatchRestPattern(n) => Builder::MatchRestPattern(self::MatchRestPattern::from_node(n)),
                Node::JSXIdentifier(n) => Builder::JSXIdentifier(self::JSXIdentifier::from_node(n)),
                Node::JSXMemberExpression(n) => Builder::JSXMemberExpression(self::JSXMemberExpression::from_node(n)),
                Node::JSXNamespacedName(n) => Builder::JSXNamespacedName(self::JSXNamespacedName::from_node(n)),
                Node::JSXEmptyExpression(n) => Builder::JSXEmptyExpression(self::JSXEmptyExpression::from_node(n)),
                Node::JSXExpressionContainer(n) => Builder::JSXExpressionContainer(self::JSXExpressionContainer::from_node(n)),
                Node::JSXSpreadChild(n) => Builder::JSXSpreadChild(self::JSXSpreadChild::from_node(n)),
                Node::JSXOpeningElement(n) => Builder::JSXOpeningElement(self::JSXOpeningElement::from_node(n)),
                Node::JSXClosingElement(n) => Builder::JSXClosingElement(self::JSXClosingElement::from_node(n)),
                Node::JSXAttribute(n) => Builder::JSXAttribute(self::JSXAttribute::from_node(n)),
                Node::JSXSpreadAttribute(n) => Builder::JSXSpreadAttribute(self::JSXSpreadAttribute::from_node(n)),
                Node::JSXStringLiteral(n) => Builder::JSXStringLiteral(self::JSXStringLiteral::from_node(n)),
                Node::JSXText(n) => Builder::JSXText(self::JSXText::from_node(n)),
                Node::JSXElement(n) => Builder::JSXElement(self::JSXElement::from_node(n)),
                Node::JSXFragment(n) => Builder::JSXFragment(self::JSXFragment::from_node(n)),
                Node::JSXOpeningFragment(n) => Builder::JSXOpeningFragment(self::JSXOpeningFragment::from_node(n)),
                Node::JSXClosingFragment(n) => Builder::JSXClosingFragment(self::JSXClosingFragment::from_node(n)),
                Node::ExistsTypeAnnotation(n) => Builder::ExistsTypeAnnotation(self::ExistsTypeAnnotation::from_node(n)),
                Node::EmptyTypeAnnotation(n) => Builder::EmptyTypeAnnotation(self::EmptyTypeAnnotation::from_node(n)),
                Node::StringTypeAnnotation(n) => Builder::StringTypeAnnotation(self::StringTypeAnnotation::from_node(n)),
                Node::NumberTypeAnnotation(n) => Builder::NumberTypeAnnotation(self::NumberTypeAnnotation::from_node(n)),
                Node::StringLiteralTypeAnnotation(n) => Builder::StringLiteralTypeAnnotation(self::StringLiteralTypeAnnotation::from_node(n)),
                Node::NumberLiteralTypeAnnotation(n) => Builder::NumberLiteralTypeAnnotation(self::NumberLiteralTypeAnnotation::from_node(n)),
                Node::BigIntLiteralTypeAnnotation(n) => Builder::BigIntLiteralTypeAnnotation(self::BigIntLiteralTypeAnnotation::from_node(n)),
                Node::BooleanTypeAnnotation(n) => Builder::BooleanTypeAnnotation(self::BooleanTypeAnnotation::from_node(n)),
                Node::BooleanLiteralTypeAnnotation(n) => Builder::BooleanLiteralTypeAnnotation(self::BooleanLiteralTypeAnnotation::from_node(n)),
                Node::NullLiteralTypeAnnotation(n) => Builder::NullLiteralTypeAnnotation(self::NullLiteralTypeAnnotation::from_node(n)),
                Node::SymbolTypeAnnotation(n) => Builder::SymbolTypeAnnotation(self::SymbolTypeAnnotation::from_node(n)),
                Node::AnyTypeAnnotation(n) => Builder::AnyTypeAnnotation(self::AnyTypeAnnotation::from_node(n)),
                Node::MixedTypeAnnotation(n) => Builder::MixedTypeAnnotation(self::MixedTypeAnnotation::from_node(n)),
                Node::BigIntTypeAnnotation(n) => Builder::BigIntTypeAnnotation(self::BigIntTypeAnnotation::from_node(n)),
                Node::VoidTypeAnnotation(n) => Builder::VoidTypeAnnotation(self::VoidTypeAnnotation::from_node(n)),
                Node::NeverTypeAnnotation(n) => Builder::NeverTypeAnnotation(self::NeverTypeAnnotation::from_node(n)),
                Node::UnknownTypeAnnotation(n) => Builder::UnknownTypeAnnotation(self::UnknownTypeAnnotation::from_node(n)),
                Node::UndefinedTypeAnnotation(n) => Builder::UndefinedTypeAnnotation(self::UndefinedTypeAnnotation::from_node(n)),
                Node::FunctionTypeAnnotation(n) => Builder::FunctionTypeAnnotation(self::FunctionTypeAnnotation::from_node(n)),
                Node::HookTypeAnnotation(n) => Builder::HookTypeAnnotation(self::HookTypeAnnotation::from_node(n)),
                Node::FunctionTypeParam(n) => Builder::FunctionTypeParam(self::FunctionTypeParam::from_node(n)),
                Node::ComponentTypeAnnotation(n) => Builder::ComponentTypeAnnotation(self::ComponentTypeAnnotation::from_node(n)),
                Node::ComponentTypeParameter(n) => Builder::ComponentTypeParameter(self::ComponentTypeParameter::from_node(n)),
                Node::NullableTypeAnnotation(n) => Builder::NullableTypeAnnotation(self::NullableTypeAnnotation::from_node(n)),
                Node::QualifiedTypeIdentifier(n) => Builder::QualifiedTypeIdentifier(self::QualifiedTypeIdentifier::from_node(n)),
                Node::TypeofTypeAnnotation(n) => Builder::TypeofTypeAnnotation(self::TypeofTypeAnnotation::from_node(n)),
                Node::KeyofTypeAnnotation(n) => Builder::KeyofTypeAnnotation(self::KeyofTypeAnnotation::from_node(n)),
                Node::TypeOperator(n) => Builder::TypeOperator(self::TypeOperator::from_node(n)),
                Node::QualifiedTypeofIdentifier(n) => Builder::QualifiedTypeofIdentifier(self::QualifiedTypeofIdentifier::from_node(n)),
                Node::TupleTypeAnnotation(n) => Builder::TupleTypeAnnotation(self::TupleTypeAnnotation::from_node(n)),
                Node::TupleTypeSpreadElement(n) => Builder::TupleTypeSpreadElement(self::TupleTypeSpreadElement::from_node(n)),
                Node::TupleTypeLabeledElement(n) => Builder::TupleTypeLabeledElement(self::TupleTypeLabeledElement::from_node(n)),
                Node::ArrayTypeAnnotation(n) => Builder::ArrayTypeAnnotation(self::ArrayTypeAnnotation::from_node(n)),
                Node::InferTypeAnnotation(n) => Builder::InferTypeAnnotation(self::InferTypeAnnotation::from_node(n)),
                Node::UnionTypeAnnotation(n) => Builder::UnionTypeAnnotation(self::UnionTypeAnnotation::from_node(n)),
                Node::IntersectionTypeAnnotation(n) => Builder::IntersectionTypeAnnotation(self::IntersectionTypeAnnotation::from_node(n)),
                Node::GenericTypeAnnotation(n) => Builder::GenericTypeAnnotation(self::GenericTypeAnnotation::from_node(n)),
                Node::IndexedAccessType(n) => Builder::IndexedAccessType(self::IndexedAccessType::from_node(n)),
                Node::OptionalIndexedAccessType(n) => Builder::OptionalIndexedAccessType(self::OptionalIndexedAccessType::from_node(n)),
                Node::ConditionalTypeAnnotation(n) => Builder::ConditionalTypeAnnotation(self::ConditionalTypeAnnotation::from_node(n)),
                Node::TypePredicate(n) => Builder::TypePredicate(self::TypePredicate::from_node(n)),
                Node::InterfaceTypeAnnotation(n) => Builder::InterfaceTypeAnnotation(self::InterfaceTypeAnnotation::from_node(n)),
                Node::TypeAlias(n) => Builder::TypeAlias(self::TypeAlias::from_node(n)),
                Node::OpaqueType(n) => Builder::OpaqueType(self::OpaqueType::from_node(n)),
                Node::InterfaceDeclaration(n) => Builder::InterfaceDeclaration(self::InterfaceDeclaration::from_node(n)),
                Node::DeclareTypeAlias(n) => Builder::DeclareTypeAlias(self::DeclareTypeAlias::from_node(n)),
                Node::DeclareOpaqueType(n) => Builder::DeclareOpaqueType(self::DeclareOpaqueType::from_node(n)),
                Node::DeclareInterface(n) => Builder::DeclareInterface(self::DeclareInterface::from_node(n)),
                Node::DeclareClass(n) => Builder::DeclareClass(self::DeclareClass::from_node(n)),
                Node::DeclareFunction(n) => Builder::DeclareFunction(self::DeclareFunction::from_node(n)),
                Node::DeclareHook(n) => Builder::DeclareHook(self::DeclareHook::from_node(n)),
                Node::DeclareComponent(n) => Builder::DeclareComponent(self::DeclareComponent::from_node(n)),
                Node::DeclareVariable(n) => Builder::DeclareVariable(self::DeclareVariable::from_node(n)),
                Node::DeclareEnum(n) => Builder::DeclareEnum(self::DeclareEnum::from_node(n)),
                Node::DeclareExportDeclaration(n) => Builder::DeclareExportDeclaration(self::DeclareExportDeclaration::from_node(n)),
                Node::DeclareExportAllDeclaration(n) => Builder::DeclareExportAllDeclaration(self::DeclareExportAllDeclaration::from_node(n)),
                Node::DeclareModule(n) => Builder::DeclareModule(self::DeclareModule::from_node(n)),
                Node::DeclareNamespace(n) => Builder::DeclareNamespace(self::DeclareNamespace::from_node(n)),
                Node::DeclareModuleExports(n) => Builder::DeclareModuleExports(self::DeclareModuleExports::from_node(n)),
                Node::InterfaceExtends(n) => Builder::InterfaceExtends(self::InterfaceExtends::from_node(n)),
                Node::ClassImplements(n) => Builder::ClassImplements(self::ClassImplements::from_node(n)),
                Node::TypeAnnotation(n) => Builder::TypeAnnotation(self::TypeAnnotation::from_node(n)),
                Node::ObjectTypeAnnotation(n) => Builder::ObjectTypeAnnotation(self::ObjectTypeAnnotation::from_node(n)),
                Node::ObjectTypeProperty(n) => Builder::ObjectTypeProperty(self::ObjectTypeProperty::from_node(n)),
                Node::ObjectTypeSpreadProperty(n) => Builder::ObjectTypeSpreadProperty(self::ObjectTypeSpreadProperty::from_node(n)),
                Node::ObjectTypeInternalSlot(n) => Builder::ObjectTypeInternalSlot(self::ObjectTypeInternalSlot::from_node(n)),
                Node::ObjectTypeCallProperty(n) => Builder::ObjectTypeCallProperty(self::ObjectTypeCallProperty::from_node(n)),
                Node::ObjectTypeIndexer(n) => Builder::ObjectTypeIndexer(self::ObjectTypeIndexer::from_node(n)),
                Node::ObjectTypeMappedTypeProperty(n) => Builder::ObjectTypeMappedTypeProperty(self::ObjectTypeMappedTypeProperty::from_node(n)),
                Node::Variance(n) => Builder::Variance(self::Variance::from_node(n)),
                Node::TypeParameterDeclaration(n) => Builder::TypeParameterDeclaration(self::TypeParameterDeclaration::from_node(n)),
                Node::TypeParameter(n) => Builder::TypeParameter(self::TypeParameter::from_node(n)),
                Node::TypeParameterInstantiation(n) => Builder::TypeParameterInstantiation(self::TypeParameterInstantiation::from_node(n)),
                Node::TypeCastExpression(n) => Builder::TypeCastExpression(self::TypeCastExpression::from_node(n)),
                Node::AsExpression(n) => Builder::AsExpression(self::AsExpression::from_node(n)),
                Node::AsConstExpression(n) => Builder::AsConstExpression(self::AsConstExpression::from_node(n)),
                Node::InferredPredicate(n) => Builder::InferredPredicate(self::InferredPredicate::from_node(n)),
                Node::DeclaredPredicate(n) => Builder::DeclaredPredicate(self::DeclaredPredicate::from_node(n)),
                Node::EnumDeclaration(n) => Builder::EnumDeclaration(self::EnumDeclaration::from_node(n)),
                Node::EnumStringBody(n) => Builder::EnumStringBody(self::EnumStringBody::from_node(n)),
                Node::EnumNumberBody(n) => Builder::EnumNumberBody(self::EnumNumberBody::from_node(n)),
                Node::EnumBigIntBody(n) => Builder::EnumBigIntBody(self::EnumBigIntBody::from_node(n)),
                Node::EnumBooleanBody(n) => Builder::EnumBooleanBody(self::EnumBooleanBody::from_node(n)),
                Node::EnumSymbolBody(n) => Builder::EnumSymbolBody(self::EnumSymbolBody::from_node(n)),
                Node::EnumDefaultedMember(n) => Builder::EnumDefaultedMember(self::EnumDefaultedMember::from_node(n)),
                Node::EnumStringMember(n) => Builder::EnumStringMember(self::EnumStringMember::from_node(n)),
                Node::EnumNumberMember(n) => Builder::EnumNumberMember(self::EnumNumberMember::from_node(n)),
                Node::EnumBigIntMember(n) => Builder::EnumBigIntMember(self::EnumBigIntMember::from_node(n)),
                Node::EnumBooleanMember(n) => Builder::EnumBooleanMember(self::EnumBooleanMember::from_node(n)),
                Node::ComponentParameter(n) => Builder::ComponentParameter(self::ComponentParameter::from_node(n)),
                Node::RecordDeclaration(n) => Builder::RecordDeclaration(self::RecordDeclaration::from_node(n)),
                Node::RecordDeclarationImplements(n) => Builder::RecordDeclarationImplements(self::RecordDeclarationImplements::from_node(n)),
                Node::RecordDeclarationBody(n) => Builder::RecordDeclarationBody(self::RecordDeclarationBody::from_node(n)),
                Node::RecordDeclarationProperty(n) => Builder::RecordDeclarationProperty(self::RecordDeclarationProperty::from_node(n)),
                Node::RecordDeclarationStaticProperty(n) => Builder::RecordDeclarationStaticProperty(self::RecordDeclarationStaticProperty::from_node(n)),
                Node::RecordExpression(n) => Builder::RecordExpression(self::RecordExpression::from_node(n)),
                Node::RecordExpressionProperties(n) => Builder::RecordExpressionProperties(self::RecordExpressionProperties::from_node(n)),
                Node::TSTypeAnnotation(n) => Builder::TSTypeAnnotation(self::TSTypeAnnotation::from_node(n)),
                Node::TSAnyKeyword(n) => Builder::TSAnyKeyword(self::TSAnyKeyword::from_node(n)),
                Node::TSNumberKeyword(n) => Builder::TSNumberKeyword(self::TSNumberKeyword::from_node(n)),
                Node::TSBooleanKeyword(n) => Builder::TSBooleanKeyword(self::TSBooleanKeyword::from_node(n)),
                Node::TSStringKeyword(n) => Builder::TSStringKeyword(self::TSStringKeyword::from_node(n)),
                Node::TSSymbolKeyword(n) => Builder::TSSymbolKeyword(self::TSSymbolKeyword::from_node(n)),
                Node::TSVoidKeyword(n) => Builder::TSVoidKeyword(self::TSVoidKeyword::from_node(n)),
                Node::TSUndefinedKeyword(n) => Builder::TSUndefinedKeyword(self::TSUndefinedKeyword::from_node(n)),
                Node::TSUnknownKeyword(n) => Builder::TSUnknownKeyword(self::TSUnknownKeyword::from_node(n)),
                Node::TSNeverKeyword(n) => Builder::TSNeverKeyword(self::TSNeverKeyword::from_node(n)),
                Node::TSBigIntKeyword(n) => Builder::TSBigIntKeyword(self::TSBigIntKeyword::from_node(n)),
                Node::TSThisType(n) => Builder::TSThisType(self::TSThisType::from_node(n)),
                Node::TSLiteralType(n) => Builder::TSLiteralType(self::TSLiteralType::from_node(n)),
                Node::TSIndexedAccessType(n) => Builder::TSIndexedAccessType(self::TSIndexedAccessType::from_node(n)),
                Node::TSArrayType(n) => Builder::TSArrayType(self::TSArrayType::from_node(n)),
                Node::TSTypeReference(n) => Builder::TSTypeReference(self::TSTypeReference::from_node(n)),
                Node::TSQualifiedName(n) => Builder::TSQualifiedName(self::TSQualifiedName::from_node(n)),
                Node::TSFunctionType(n) => Builder::TSFunctionType(self::TSFunctionType::from_node(n)),
                Node::TSConstructorType(n) => Builder::TSConstructorType(self::TSConstructorType::from_node(n)),
                Node::TSTypePredicate(n) => Builder::TSTypePredicate(self::TSTypePredicate::from_node(n)),
                Node::TSTupleType(n) => Builder::TSTupleType(self::TSTupleType::from_node(n)),
                Node::TSTypeAssertion(n) => Builder::TSTypeAssertion(self::TSTypeAssertion::from_node(n)),
                Node::TSAsExpression(n) => Builder::TSAsExpression(self::TSAsExpression::from_node(n)),
                Node::TSParameterProperty(n) => Builder::TSParameterProperty(self::TSParameterProperty::from_node(n)),
                Node::TSTypeAliasDeclaration(n) => Builder::TSTypeAliasDeclaration(self::TSTypeAliasDeclaration::from_node(n)),
                Node::TSInterfaceDeclaration(n) => Builder::TSInterfaceDeclaration(self::TSInterfaceDeclaration::from_node(n)),
                Node::TSInterfaceHeritage(n) => Builder::TSInterfaceHeritage(self::TSInterfaceHeritage::from_node(n)),
                Node::TSInterfaceBody(n) => Builder::TSInterfaceBody(self::TSInterfaceBody::from_node(n)),
                Node::TSEnumDeclaration(n) => Builder::TSEnumDeclaration(self::TSEnumDeclaration::from_node(n)),
                Node::TSEnumMember(n) => Builder::TSEnumMember(self::TSEnumMember::from_node(n)),
                Node::TSModuleDeclaration(n) => Builder::TSModuleDeclaration(self::TSModuleDeclaration::from_node(n)),
                Node::TSModuleBlock(n) => Builder::TSModuleBlock(self::TSModuleBlock::from_node(n)),
                Node::TSModuleMember(n) => Builder::TSModuleMember(self::TSModuleMember::from_node(n)),
                Node::TSTypeParameterDeclaration(n) => Builder::TSTypeParameterDeclaration(self::TSTypeParameterDeclaration::from_node(n)),
                Node::TSTypeParameter(n) => Builder::TSTypeParameter(self::TSTypeParameter::from_node(n)),
                Node::TSTypeParameterInstantiation(n) => Builder::TSTypeParameterInstantiation(self::TSTypeParameterInstantiation::from_node(n)),
                Node::TSUnionType(n) => Builder::TSUnionType(self::TSUnionType::from_node(n)),
                Node::TSIntersectionType(n) => Builder::TSIntersectionType(self::TSIntersectionType::from_node(n)),
                Node::TSTypeQuery(n) => Builder::TSTypeQuery(self::TSTypeQuery::from_node(n)),
                Node::TSConditionalType(n) => Builder::TSConditionalType(self::TSConditionalType::from_node(n)),
                Node::TSTypeLiteral(n) => Builder::TSTypeLiteral(self::TSTypeLiteral::from_node(n)),
                Node::TSPropertySignature(n) => Builder::TSPropertySignature(self::TSPropertySignature::from_node(n)),
                Node::TSMethodSignature(n) => Builder::TSMethodSignature(self::TSMethodSignature::from_node(n)),
                Node::TSIndexSignature(n) => Builder::TSIndexSignature(self::TSIndexSignature::from_node(n)),
                Node::TSCallSignatureDeclaration(n) => Builder::TSCallSignatureDeclaration(self::TSCallSignatureDeclaration::from_node(n)),
                Node::TSModifiers(n) => Builder::TSModifiers(self::TSModifiers::from_node(n)),
                Node::CoverEmptyArgs(n) => Builder::CoverEmptyArgs(self::CoverEmptyArgs::from_node(n)),
                Node::CoverTrailingComma(n) => Builder::CoverTrailingComma(self::CoverTrailingComma::from_node(n)),
                Node::CoverInitializer(n) => Builder::CoverInitializer(self::CoverInitializer::from_node(n)),
                Node::CoverRestElement(n) => Builder::CoverRestElement(self::CoverRestElement::from_node(n)),
                Node::CoverTypedIdentifier(n) => Builder::CoverTypedIdentifier(self::CoverTypedIdentifier::from_node(n)),
                Node::SHBuiltin(n) => Builder::SHBuiltin(self::SHBuiltin::from_node(n)),
                Node::ImplicitCheckedCast(n) => Builder::ImplicitCheckedCast(self::ImplicitCheckedCast::from_node(n)),
            }
        }
    }

    /// Clone-with-changes builder for [`super::Empty`].
    #[derive(Debug)]
    pub struct Empty<'gc> {
        is_changed: bool,
        pub(super) inner: super::Empty<'gc>,
    }
    impl<'gc> Empty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::Empty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::Empty {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::Empty(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::Metadata`].
    #[derive(Debug)]
    pub struct Metadata<'gc> {
        is_changed: bool,
        pub(super) inner: super::Metadata<'gc>,
    }
    impl<'gc> Metadata<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::Metadata<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::Metadata {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::Metadata(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::Program`].
    #[derive(Debug)]
    pub struct Program<'gc> {
        is_changed: bool,
        pub(super) inner: super::Program<'gc>,
    }
    impl<'gc> Program<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::Program<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::Program {
                    metadata: node.metadata.duplicate(),
                    body: node.body.duplicate(),
                    scope: Cell::new(node.scope.get()),
                    sem_info: Cell::new(node.sem_info.get()),
                    strictness: Cell::new(node.strictness.get()),
                    is_method_definition: Cell::new(node.is_method_definition.get()),
                    decorations: Cell::new(node.decorations.get()),
                    dummy_param_list: Cell::new(node.dummy_param_list.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::Program(self.inner))
        }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: NodeList<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::FunctionExpression`].
    #[derive(Debug)]
    pub struct FunctionExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::FunctionExpression<'gc>,
    }
    impl<'gc> FunctionExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::FunctionExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::FunctionExpression {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    params: node.params.duplicate(),
                    body: node.body.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    return_type: node.return_type.duplicate(),
                    predicate: node.predicate.duplicate(),
                    generator: Cell::new(node.generator.get()),
                    r#async: Cell::new(node.r#async.get()),
                    scope: Cell::new(node.scope.get()),
                    sem_info: Cell::new(node.sem_info.get()),
                    strictness: Cell::new(node.strictness.get()),
                    is_method_definition: Cell::new(node.is_method_definition.get()),
                    decorations: Cell::new(node.decorations.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::FunctionExpression(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.return_type = return_type; }
        /// Set the `predicate` field and mark the builder changed.
        pub fn predicate(&mut self, predicate: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.predicate = predicate; }
    }
    /// Clone-with-changes builder for [`super::ArrowFunctionExpression`].
    #[derive(Debug)]
    pub struct ArrowFunctionExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::ArrowFunctionExpression<'gc>,
    }
    impl<'gc> ArrowFunctionExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ArrowFunctionExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ArrowFunctionExpression {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                    body: node.body.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    return_type: node.return_type.duplicate(),
                    predicate: node.predicate.duplicate(),
                    expression: Cell::new(node.expression.get()),
                    r#async: Cell::new(node.r#async.get()),
                    scope: Cell::new(node.scope.get()),
                    sem_info: Cell::new(node.sem_info.get()),
                    strictness: Cell::new(node.strictness.get()),
                    is_method_definition: Cell::new(node.is_method_definition.get()),
                    decorations: Cell::new(node.decorations.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ArrowFunctionExpression(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.return_type = return_type; }
        /// Set the `predicate` field and mark the builder changed.
        pub fn predicate(&mut self, predicate: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.predicate = predicate; }
    }
    /// Clone-with-changes builder for [`super::FunctionDeclaration`].
    #[derive(Debug)]
    pub struct FunctionDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::FunctionDeclaration<'gc>,
    }
    impl<'gc> FunctionDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::FunctionDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::FunctionDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    params: node.params.duplicate(),
                    body: node.body.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    return_type: node.return_type.duplicate(),
                    predicate: node.predicate.duplicate(),
                    generator: Cell::new(node.generator.get()),
                    r#async: Cell::new(node.r#async.get()),
                    scope: Cell::new(node.scope.get()),
                    sem_info: Cell::new(node.sem_info.get()),
                    strictness: Cell::new(node.strictness.get()),
                    is_method_definition: Cell::new(node.is_method_definition.get()),
                    decorations: Cell::new(node.decorations.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::FunctionDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.return_type = return_type; }
        /// Set the `predicate` field and mark the builder changed.
        pub fn predicate(&mut self, predicate: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.predicate = predicate; }
    }
    /// Clone-with-changes builder for [`super::ComponentDeclaration`].
    #[derive(Debug)]
    pub struct ComponentDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::ComponentDeclaration<'gc>,
    }
    impl<'gc> ComponentDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ComponentDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ComponentDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    params: node.params.duplicate(),
                    body: node.body.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    renders_type: node.renders_type.duplicate(),
                    r#async: Cell::new(node.r#async.get()),
                    scope: Cell::new(node.scope.get()),
                    sem_info: Cell::new(node.sem_info.get()),
                    strictness: Cell::new(node.strictness.get()),
                    is_method_definition: Cell::new(node.is_method_definition.get()),
                    decorations: Cell::new(node.decorations.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ComponentDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `renders_type` field and mark the builder changed.
        pub fn renders_type(&mut self, renders_type: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.renders_type = renders_type; }
    }
    /// Clone-with-changes builder for [`super::HookDeclaration`].
    #[derive(Debug)]
    pub struct HookDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::HookDeclaration<'gc>,
    }
    impl<'gc> HookDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::HookDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::HookDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    params: node.params.duplicate(),
                    body: node.body.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    return_type: node.return_type.duplicate(),
                    r#async: Cell::new(node.r#async.get()),
                    scope: Cell::new(node.scope.get()),
                    sem_info: Cell::new(node.sem_info.get()),
                    strictness: Cell::new(node.strictness.get()),
                    is_method_definition: Cell::new(node.is_method_definition.get()),
                    decorations: Cell::new(node.decorations.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::HookDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.return_type = return_type; }
    }
    /// Clone-with-changes builder for [`super::MatchStatement`].
    #[derive(Debug)]
    pub struct MatchStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchStatement<'gc>,
    }
    impl<'gc> MatchStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchStatement {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                    cases: node.cases.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchStatement(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
        /// Set the `cases` field and mark the builder changed.
        pub fn cases(&mut self, cases: NodeList<'gc>) { self.is_changed = true; self.inner.cases = cases; }
    }
    /// Clone-with-changes builder for [`super::WhileStatement`].
    #[derive(Debug)]
    pub struct WhileStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::WhileStatement<'gc>,
    }
    impl<'gc> WhileStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::WhileStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::WhileStatement {
                    metadata: node.metadata.duplicate(),
                    body: node.body.duplicate(),
                    test: node.test.duplicate(),
                    label_index: Cell::new(node.label_index.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::WhileStatement(self.inner))
        }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `test` field and mark the builder changed.
        pub fn test(&mut self, test: &'gc Node<'gc>) { self.is_changed = true; self.inner.test = test; }
    }
    /// Clone-with-changes builder for [`super::DoWhileStatement`].
    #[derive(Debug)]
    pub struct DoWhileStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::DoWhileStatement<'gc>,
    }
    impl<'gc> DoWhileStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DoWhileStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DoWhileStatement {
                    metadata: node.metadata.duplicate(),
                    body: node.body.duplicate(),
                    test: node.test.duplicate(),
                    label_index: Cell::new(node.label_index.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DoWhileStatement(self.inner))
        }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `test` field and mark the builder changed.
        pub fn test(&mut self, test: &'gc Node<'gc>) { self.is_changed = true; self.inner.test = test; }
    }
    /// Clone-with-changes builder for [`super::ForInStatement`].
    #[derive(Debug)]
    pub struct ForInStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::ForInStatement<'gc>,
    }
    impl<'gc> ForInStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ForInStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ForInStatement {
                    metadata: node.metadata.duplicate(),
                    left: node.left.duplicate(),
                    right: node.right.duplicate(),
                    body: node.body.duplicate(),
                    label_index: Cell::new(node.label_index.get()),
                    scope: Cell::new(node.scope.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ForInStatement(self.inner))
        }
        /// Set the `left` field and mark the builder changed.
        pub fn left(&mut self, left: &'gc Node<'gc>) { self.is_changed = true; self.inner.left = left; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: &'gc Node<'gc>) { self.is_changed = true; self.inner.right = right; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::ForOfStatement`].
    #[derive(Debug)]
    pub struct ForOfStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::ForOfStatement<'gc>,
    }
    impl<'gc> ForOfStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ForOfStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ForOfStatement {
                    metadata: node.metadata.duplicate(),
                    left: node.left.duplicate(),
                    right: node.right.duplicate(),
                    body: node.body.duplicate(),
                    r#await: Cell::new(node.r#await.get()),
                    label_index: Cell::new(node.label_index.get()),
                    scope: Cell::new(node.scope.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ForOfStatement(self.inner))
        }
        /// Set the `left` field and mark the builder changed.
        pub fn left(&mut self, left: &'gc Node<'gc>) { self.is_changed = true; self.inner.left = left; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: &'gc Node<'gc>) { self.is_changed = true; self.inner.right = right; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::ForStatement`].
    #[derive(Debug)]
    pub struct ForStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::ForStatement<'gc>,
    }
    impl<'gc> ForStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ForStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ForStatement {
                    metadata: node.metadata.duplicate(),
                    init: node.init.duplicate(),
                    test: node.test.duplicate(),
                    update: node.update.duplicate(),
                    body: node.body.duplicate(),
                    label_index: Cell::new(node.label_index.get()),
                    scope: Cell::new(node.scope.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ForStatement(self.inner))
        }
        /// Set the `init` field and mark the builder changed.
        pub fn init(&mut self, init: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.init = init; }
        /// Set the `test` field and mark the builder changed.
        pub fn test(&mut self, test: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.test = test; }
        /// Set the `update` field and mark the builder changed.
        pub fn update(&mut self, update: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.update = update; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::DebuggerStatement`].
    #[derive(Debug)]
    pub struct DebuggerStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::DebuggerStatement<'gc>,
    }
    impl<'gc> DebuggerStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DebuggerStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DebuggerStatement {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DebuggerStatement(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::EmptyStatement`].
    #[derive(Debug)]
    pub struct EmptyStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::EmptyStatement<'gc>,
    }
    impl<'gc> EmptyStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EmptyStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EmptyStatement {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EmptyStatement(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::BlockStatement`].
    #[derive(Debug)]
    pub struct BlockStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::BlockStatement<'gc>,
    }
    impl<'gc> BlockStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::BlockStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::BlockStatement {
                    metadata: node.metadata.duplicate(),
                    body: node.body.duplicate(),
                    implicit: Cell::new(node.implicit.get()),
                    scope: Cell::new(node.scope.get()),
                    buffer_id: Cell::new(node.buffer_id.get()),
                    is_lazy_function_body: Cell::new(node.is_lazy_function_body.get()),
                    param_yield: Cell::new(node.param_yield.get()),
                    param_await: Cell::new(node.param_await.get()),
                    contains_arrow_functions: Cell::new(node.contains_arrow_functions.get()),
                    may_contain_arrow_functions_using_arguments: Cell::new(node.may_contain_arrow_functions_using_arguments.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::BlockStatement(self.inner))
        }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: NodeList<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::StaticBlock`].
    #[derive(Debug)]
    pub struct StaticBlock<'gc> {
        is_changed: bool,
        pub(super) inner: super::StaticBlock<'gc>,
    }
    impl<'gc> StaticBlock<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::StaticBlock<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::StaticBlock {
                    metadata: node.metadata.duplicate(),
                    body: node.body.duplicate(),
                    scope: Cell::new(node.scope.get()),
                    function_info: Cell::new(node.function_info.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::StaticBlock(self.inner))
        }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: NodeList<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::BreakStatement`].
    #[derive(Debug)]
    pub struct BreakStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::BreakStatement<'gc>,
    }
    impl<'gc> BreakStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::BreakStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::BreakStatement {
                    metadata: node.metadata.duplicate(),
                    label: node.label.duplicate(),
                    label_index: Cell::new(node.label_index.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::BreakStatement(self.inner))
        }
        /// Set the `label` field and mark the builder changed.
        pub fn label(&mut self, label: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.label = label; }
    }
    /// Clone-with-changes builder for [`super::ContinueStatement`].
    #[derive(Debug)]
    pub struct ContinueStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::ContinueStatement<'gc>,
    }
    impl<'gc> ContinueStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ContinueStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ContinueStatement {
                    metadata: node.metadata.duplicate(),
                    label: node.label.duplicate(),
                    label_index: Cell::new(node.label_index.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ContinueStatement(self.inner))
        }
        /// Set the `label` field and mark the builder changed.
        pub fn label(&mut self, label: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.label = label; }
    }
    /// Clone-with-changes builder for [`super::ThrowStatement`].
    #[derive(Debug)]
    pub struct ThrowStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::ThrowStatement<'gc>,
    }
    impl<'gc> ThrowStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ThrowStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ThrowStatement {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ThrowStatement(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::ReturnStatement`].
    #[derive(Debug)]
    pub struct ReturnStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::ReturnStatement<'gc>,
    }
    impl<'gc> ReturnStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ReturnStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ReturnStatement {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ReturnStatement(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::WithStatement`].
    #[derive(Debug)]
    pub struct WithStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::WithStatement<'gc>,
    }
    impl<'gc> WithStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::WithStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::WithStatement {
                    metadata: node.metadata.duplicate(),
                    object: node.object.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::WithStatement(self.inner))
        }
        /// Set the `object` field and mark the builder changed.
        pub fn object(&mut self, object: &'gc Node<'gc>) { self.is_changed = true; self.inner.object = object; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::SwitchStatement`].
    #[derive(Debug)]
    pub struct SwitchStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::SwitchStatement<'gc>,
    }
    impl<'gc> SwitchStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::SwitchStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::SwitchStatement {
                    metadata: node.metadata.duplicate(),
                    discriminant: node.discriminant.duplicate(),
                    cases: node.cases.duplicate(),
                    label_index: Cell::new(node.label_index.get()),
                    scope: Cell::new(node.scope.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::SwitchStatement(self.inner))
        }
        /// Set the `discriminant` field and mark the builder changed.
        pub fn discriminant(&mut self, discriminant: &'gc Node<'gc>) { self.is_changed = true; self.inner.discriminant = discriminant; }
        /// Set the `cases` field and mark the builder changed.
        pub fn cases(&mut self, cases: NodeList<'gc>) { self.is_changed = true; self.inner.cases = cases; }
    }
    /// Clone-with-changes builder for [`super::LabeledStatement`].
    #[derive(Debug)]
    pub struct LabeledStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::LabeledStatement<'gc>,
    }
    impl<'gc> LabeledStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::LabeledStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::LabeledStatement {
                    metadata: node.metadata.duplicate(),
                    label: node.label.duplicate(),
                    body: node.body.duplicate(),
                    label_index: Cell::new(node.label_index.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::LabeledStatement(self.inner))
        }
        /// Set the `label` field and mark the builder changed.
        pub fn label(&mut self, label: &'gc Node<'gc>) { self.is_changed = true; self.inner.label = label; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::ExpressionStatement`].
    #[derive(Debug)]
    pub struct ExpressionStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::ExpressionStatement<'gc>,
    }
    impl<'gc> ExpressionStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ExpressionStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ExpressionStatement {
                    metadata: node.metadata.duplicate(),
                    expression: node.expression.duplicate(),
                    directive: Cell::new(node.directive.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ExpressionStatement(self.inner))
        }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
    }
    /// Clone-with-changes builder for [`super::TryStatement`].
    #[derive(Debug)]
    pub struct TryStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::TryStatement<'gc>,
    }
    impl<'gc> TryStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TryStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TryStatement {
                    metadata: node.metadata.duplicate(),
                    block: node.block.duplicate(),
                    handler: node.handler.duplicate(),
                    finalizer: node.finalizer.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TryStatement(self.inner))
        }
        /// Set the `block` field and mark the builder changed.
        pub fn block(&mut self, block: &'gc Node<'gc>) { self.is_changed = true; self.inner.block = block; }
        /// Set the `handler` field and mark the builder changed.
        pub fn handler(&mut self, handler: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.handler = handler; }
        /// Set the `finalizer` field and mark the builder changed.
        pub fn finalizer(&mut self, finalizer: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.finalizer = finalizer; }
    }
    /// Clone-with-changes builder for [`super::IfStatement`].
    #[derive(Debug)]
    pub struct IfStatement<'gc> {
        is_changed: bool,
        pub(super) inner: super::IfStatement<'gc>,
    }
    impl<'gc> IfStatement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::IfStatement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::IfStatement {
                    metadata: node.metadata.duplicate(),
                    test: node.test.duplicate(),
                    consequent: node.consequent.duplicate(),
                    alternate: node.alternate.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::IfStatement(self.inner))
        }
        /// Set the `test` field and mark the builder changed.
        pub fn test(&mut self, test: &'gc Node<'gc>) { self.is_changed = true; self.inner.test = test; }
        /// Set the `consequent` field and mark the builder changed.
        pub fn consequent(&mut self, consequent: &'gc Node<'gc>) { self.is_changed = true; self.inner.consequent = consequent; }
        /// Set the `alternate` field and mark the builder changed.
        pub fn alternate(&mut self, alternate: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.alternate = alternate; }
    }
    /// Clone-with-changes builder for [`super::NullLiteral`].
    #[derive(Debug)]
    pub struct NullLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::NullLiteral<'gc>,
    }
    impl<'gc> NullLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::NullLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::NullLiteral {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::NullLiteral(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::BooleanLiteral`].
    #[derive(Debug)]
    pub struct BooleanLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::BooleanLiteral<'gc>,
    }
    impl<'gc> BooleanLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::BooleanLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::BooleanLiteral {
                    metadata: node.metadata.duplicate(),
                    value: Cell::new(node.value.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::BooleanLiteral(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::StringLiteral`].
    #[derive(Debug)]
    pub struct StringLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::StringLiteral<'gc>,
    }
    impl<'gc> StringLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::StringLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::StringLiteral {
                    metadata: node.metadata.duplicate(),
                    value: Cell::new(node.value.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::StringLiteral(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::NumericLiteral`].
    #[derive(Debug)]
    pub struct NumericLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::NumericLiteral<'gc>,
    }
    impl<'gc> NumericLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::NumericLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::NumericLiteral {
                    metadata: node.metadata.duplicate(),
                    value: Cell::new(node.value.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::NumericLiteral(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::RegExpLiteral`].
    #[derive(Debug)]
    pub struct RegExpLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::RegExpLiteral<'gc>,
    }
    impl<'gc> RegExpLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::RegExpLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::RegExpLiteral {
                    metadata: node.metadata.duplicate(),
                    pattern: Cell::new(node.pattern.get()),
                    flags: Cell::new(node.flags.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::RegExpLiteral(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::BigIntLiteral`].
    #[derive(Debug)]
    pub struct BigIntLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::BigIntLiteral<'gc>,
    }
    impl<'gc> BigIntLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::BigIntLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::BigIntLiteral {
                    metadata: node.metadata.duplicate(),
                    bigint: Cell::new(node.bigint.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::BigIntLiteral(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::ThisExpression`].
    #[derive(Debug)]
    pub struct ThisExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::ThisExpression<'gc>,
    }
    impl<'gc> ThisExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ThisExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ThisExpression {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ThisExpression(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::Super`].
    #[derive(Debug)]
    pub struct Super<'gc> {
        is_changed: bool,
        pub(super) inner: super::Super<'gc>,
    }
    impl<'gc> Super<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::Super<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::Super {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::Super(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::SequenceExpression`].
    #[derive(Debug)]
    pub struct SequenceExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::SequenceExpression<'gc>,
    }
    impl<'gc> SequenceExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::SequenceExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::SequenceExpression {
                    metadata: node.metadata.duplicate(),
                    expressions: node.expressions.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::SequenceExpression(self.inner))
        }
        /// Set the `expressions` field and mark the builder changed.
        pub fn expressions(&mut self, expressions: NodeList<'gc>) { self.is_changed = true; self.inner.expressions = expressions; }
    }
    /// Clone-with-changes builder for [`super::ObjectExpression`].
    #[derive(Debug)]
    pub struct ObjectExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::ObjectExpression<'gc>,
    }
    impl<'gc> ObjectExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ObjectExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ObjectExpression {
                    metadata: node.metadata.duplicate(),
                    properties: node.properties.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ObjectExpression(self.inner))
        }
        /// Set the `properties` field and mark the builder changed.
        pub fn properties(&mut self, properties: NodeList<'gc>) { self.is_changed = true; self.inner.properties = properties; }
    }
    /// Clone-with-changes builder for [`super::ArrayExpression`].
    #[derive(Debug)]
    pub struct ArrayExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::ArrayExpression<'gc>,
    }
    impl<'gc> ArrayExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ArrayExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ArrayExpression {
                    metadata: node.metadata.duplicate(),
                    elements: node.elements.duplicate(),
                    trailing_comma: Cell::new(node.trailing_comma.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ArrayExpression(self.inner))
        }
        /// Set the `elements` field and mark the builder changed.
        pub fn elements(&mut self, elements: NodeList<'gc>) { self.is_changed = true; self.inner.elements = elements; }
    }
    /// Clone-with-changes builder for [`super::SpreadElement`].
    #[derive(Debug)]
    pub struct SpreadElement<'gc> {
        is_changed: bool,
        pub(super) inner: super::SpreadElement<'gc>,
    }
    impl<'gc> SpreadElement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::SpreadElement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::SpreadElement {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::SpreadElement(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::NewExpression`].
    #[derive(Debug)]
    pub struct NewExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::NewExpression<'gc>,
    }
    impl<'gc> NewExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::NewExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::NewExpression {
                    metadata: node.metadata.duplicate(),
                    callee: node.callee.duplicate(),
                    type_arguments: node.type_arguments.duplicate(),
                    arguments: node.arguments.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::NewExpression(self.inner))
        }
        /// Set the `callee` field and mark the builder changed.
        pub fn callee(&mut self, callee: &'gc Node<'gc>) { self.is_changed = true; self.inner.callee = callee; }
        /// Set the `type_arguments` field and mark the builder changed.
        pub fn type_arguments(&mut self, type_arguments: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_arguments = type_arguments; }
        /// Set the `arguments` field and mark the builder changed.
        pub fn arguments(&mut self, arguments: NodeList<'gc>) { self.is_changed = true; self.inner.arguments = arguments; }
    }
    /// Clone-with-changes builder for [`super::YieldExpression`].
    #[derive(Debug)]
    pub struct YieldExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::YieldExpression<'gc>,
    }
    impl<'gc> YieldExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::YieldExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::YieldExpression {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                    delegate: Cell::new(node.delegate.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::YieldExpression(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::AwaitExpression`].
    #[derive(Debug)]
    pub struct AwaitExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::AwaitExpression<'gc>,
    }
    impl<'gc> AwaitExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::AwaitExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::AwaitExpression {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::AwaitExpression(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::ImportExpression`].
    #[derive(Debug)]
    pub struct ImportExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::ImportExpression<'gc>,
    }
    impl<'gc> ImportExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ImportExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ImportExpression {
                    metadata: node.metadata.duplicate(),
                    source: node.source.duplicate(),
                    options: node.options.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ImportExpression(self.inner))
        }
        /// Set the `source` field and mark the builder changed.
        pub fn source(&mut self, source: &'gc Node<'gc>) { self.is_changed = true; self.inner.source = source; }
        /// Set the `options` field and mark the builder changed.
        pub fn options(&mut self, options: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.options = options; }
    }
    /// Clone-with-changes builder for [`super::CallExpression`].
    #[derive(Debug)]
    pub struct CallExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::CallExpression<'gc>,
    }
    impl<'gc> CallExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::CallExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::CallExpression {
                    metadata: node.metadata.duplicate(),
                    callee: node.callee.duplicate(),
                    type_arguments: node.type_arguments.duplicate(),
                    arguments: node.arguments.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::CallExpression(self.inner))
        }
        /// Set the `callee` field and mark the builder changed.
        pub fn callee(&mut self, callee: &'gc Node<'gc>) { self.is_changed = true; self.inner.callee = callee; }
        /// Set the `type_arguments` field and mark the builder changed.
        pub fn type_arguments(&mut self, type_arguments: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_arguments = type_arguments; }
        /// Set the `arguments` field and mark the builder changed.
        pub fn arguments(&mut self, arguments: NodeList<'gc>) { self.is_changed = true; self.inner.arguments = arguments; }
    }
    /// Clone-with-changes builder for [`super::OptionalCallExpression`].
    #[derive(Debug)]
    pub struct OptionalCallExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::OptionalCallExpression<'gc>,
    }
    impl<'gc> OptionalCallExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::OptionalCallExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::OptionalCallExpression {
                    metadata: node.metadata.duplicate(),
                    callee: node.callee.duplicate(),
                    type_arguments: node.type_arguments.duplicate(),
                    arguments: node.arguments.duplicate(),
                    optional: Cell::new(node.optional.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::OptionalCallExpression(self.inner))
        }
        /// Set the `callee` field and mark the builder changed.
        pub fn callee(&mut self, callee: &'gc Node<'gc>) { self.is_changed = true; self.inner.callee = callee; }
        /// Set the `type_arguments` field and mark the builder changed.
        pub fn type_arguments(&mut self, type_arguments: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_arguments = type_arguments; }
        /// Set the `arguments` field and mark the builder changed.
        pub fn arguments(&mut self, arguments: NodeList<'gc>) { self.is_changed = true; self.inner.arguments = arguments; }
    }
    /// Clone-with-changes builder for [`super::AssignmentExpression`].
    #[derive(Debug)]
    pub struct AssignmentExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::AssignmentExpression<'gc>,
    }
    impl<'gc> AssignmentExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::AssignmentExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::AssignmentExpression {
                    metadata: node.metadata.duplicate(),
                    operator: Cell::new(node.operator.get()),
                    left: node.left.duplicate(),
                    right: node.right.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::AssignmentExpression(self.inner))
        }
        /// Set the `left` field and mark the builder changed.
        pub fn left(&mut self, left: &'gc Node<'gc>) { self.is_changed = true; self.inner.left = left; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: &'gc Node<'gc>) { self.is_changed = true; self.inner.right = right; }
    }
    /// Clone-with-changes builder for [`super::UnaryExpression`].
    #[derive(Debug)]
    pub struct UnaryExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::UnaryExpression<'gc>,
    }
    impl<'gc> UnaryExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::UnaryExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::UnaryExpression {
                    metadata: node.metadata.duplicate(),
                    operator: Cell::new(node.operator.get()),
                    argument: node.argument.duplicate(),
                    prefix: Cell::new(node.prefix.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::UnaryExpression(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::UpdateExpression`].
    #[derive(Debug)]
    pub struct UpdateExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::UpdateExpression<'gc>,
    }
    impl<'gc> UpdateExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::UpdateExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::UpdateExpression {
                    metadata: node.metadata.duplicate(),
                    operator: Cell::new(node.operator.get()),
                    argument: node.argument.duplicate(),
                    prefix: Cell::new(node.prefix.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::UpdateExpression(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::MemberExpression`].
    #[derive(Debug)]
    pub struct MemberExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::MemberExpression<'gc>,
    }
    impl<'gc> MemberExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MemberExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MemberExpression {
                    metadata: node.metadata.duplicate(),
                    object: node.object.duplicate(),
                    property: node.property.duplicate(),
                    computed: Cell::new(node.computed.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MemberExpression(self.inner))
        }
        /// Set the `object` field and mark the builder changed.
        pub fn object(&mut self, object: &'gc Node<'gc>) { self.is_changed = true; self.inner.object = object; }
        /// Set the `property` field and mark the builder changed.
        pub fn property(&mut self, property: &'gc Node<'gc>) { self.is_changed = true; self.inner.property = property; }
    }
    /// Clone-with-changes builder for [`super::OptionalMemberExpression`].
    #[derive(Debug)]
    pub struct OptionalMemberExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::OptionalMemberExpression<'gc>,
    }
    impl<'gc> OptionalMemberExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::OptionalMemberExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::OptionalMemberExpression {
                    metadata: node.metadata.duplicate(),
                    object: node.object.duplicate(),
                    property: node.property.duplicate(),
                    computed: Cell::new(node.computed.get()),
                    optional: Cell::new(node.optional.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::OptionalMemberExpression(self.inner))
        }
        /// Set the `object` field and mark the builder changed.
        pub fn object(&mut self, object: &'gc Node<'gc>) { self.is_changed = true; self.inner.object = object; }
        /// Set the `property` field and mark the builder changed.
        pub fn property(&mut self, property: &'gc Node<'gc>) { self.is_changed = true; self.inner.property = property; }
    }
    /// Clone-with-changes builder for [`super::LogicalExpression`].
    #[derive(Debug)]
    pub struct LogicalExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::LogicalExpression<'gc>,
    }
    impl<'gc> LogicalExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::LogicalExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::LogicalExpression {
                    metadata: node.metadata.duplicate(),
                    left: node.left.duplicate(),
                    right: node.right.duplicate(),
                    operator: Cell::new(node.operator.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::LogicalExpression(self.inner))
        }
        /// Set the `left` field and mark the builder changed.
        pub fn left(&mut self, left: &'gc Node<'gc>) { self.is_changed = true; self.inner.left = left; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: &'gc Node<'gc>) { self.is_changed = true; self.inner.right = right; }
    }
    /// Clone-with-changes builder for [`super::ConditionalExpression`].
    #[derive(Debug)]
    pub struct ConditionalExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::ConditionalExpression<'gc>,
    }
    impl<'gc> ConditionalExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ConditionalExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ConditionalExpression {
                    metadata: node.metadata.duplicate(),
                    test: node.test.duplicate(),
                    alternate: node.alternate.duplicate(),
                    consequent: node.consequent.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ConditionalExpression(self.inner))
        }
        /// Set the `test` field and mark the builder changed.
        pub fn test(&mut self, test: &'gc Node<'gc>) { self.is_changed = true; self.inner.test = test; }
        /// Set the `alternate` field and mark the builder changed.
        pub fn alternate(&mut self, alternate: &'gc Node<'gc>) { self.is_changed = true; self.inner.alternate = alternate; }
        /// Set the `consequent` field and mark the builder changed.
        pub fn consequent(&mut self, consequent: &'gc Node<'gc>) { self.is_changed = true; self.inner.consequent = consequent; }
    }
    /// Clone-with-changes builder for [`super::BinaryExpression`].
    #[derive(Debug)]
    pub struct BinaryExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::BinaryExpression<'gc>,
    }
    impl<'gc> BinaryExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::BinaryExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::BinaryExpression {
                    metadata: node.metadata.duplicate(),
                    left: node.left.duplicate(),
                    right: node.right.duplicate(),
                    operator: Cell::new(node.operator.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::BinaryExpression(self.inner))
        }
        /// Set the `left` field and mark the builder changed.
        pub fn left(&mut self, left: &'gc Node<'gc>) { self.is_changed = true; self.inner.left = left; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: &'gc Node<'gc>) { self.is_changed = true; self.inner.right = right; }
    }
    /// Clone-with-changes builder for [`super::Directive`].
    #[derive(Debug)]
    pub struct Directive<'gc> {
        is_changed: bool,
        pub(super) inner: super::Directive<'gc>,
    }
    impl<'gc> Directive<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::Directive<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::Directive {
                    metadata: node.metadata.duplicate(),
                    value: node.value.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::Directive(self.inner))
        }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
    }
    /// Clone-with-changes builder for [`super::DirectiveLiteral`].
    #[derive(Debug)]
    pub struct DirectiveLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::DirectiveLiteral<'gc>,
    }
    impl<'gc> DirectiveLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DirectiveLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DirectiveLiteral {
                    metadata: node.metadata.duplicate(),
                    value: Cell::new(node.value.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DirectiveLiteral(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::Identifier`].
    #[derive(Debug)]
    pub struct Identifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::Identifier<'gc>,
    }
    impl<'gc> Identifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::Identifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::Identifier {
                    metadata: node.metadata.duplicate(),
                    name: Cell::new(node.name.get()),
                    type_annotation: node.type_annotation.duplicate(),
                    optional: Cell::new(node.optional.get()),
                    unresolvable: Cell::new(node.unresolvable.get()),
                    decl_state: Cell::new(node.decl_state.get()),
                    decl: Cell::new(node.decl.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::Identifier(self.inner))
        }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::PrivateName`].
    #[derive(Debug)]
    pub struct PrivateName<'gc> {
        is_changed: bool,
        pub(super) inner: super::PrivateName<'gc>,
    }
    impl<'gc> PrivateName<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::PrivateName<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::PrivateName {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::PrivateName(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
    }
    /// Clone-with-changes builder for [`super::MetaProperty`].
    #[derive(Debug)]
    pub struct MetaProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::MetaProperty<'gc>,
    }
    impl<'gc> MetaProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MetaProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MetaProperty {
                    metadata: node.metadata.duplicate(),
                    meta: node.meta.duplicate(),
                    property: node.property.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MetaProperty(self.inner))
        }
        /// Set the `meta` field and mark the builder changed.
        pub fn meta(&mut self, meta: &'gc Node<'gc>) { self.is_changed = true; self.inner.meta = meta; }
        /// Set the `property` field and mark the builder changed.
        pub fn property(&mut self, property: &'gc Node<'gc>) { self.is_changed = true; self.inner.property = property; }
    }
    /// Clone-with-changes builder for [`super::SwitchCase`].
    #[derive(Debug)]
    pub struct SwitchCase<'gc> {
        is_changed: bool,
        pub(super) inner: super::SwitchCase<'gc>,
    }
    impl<'gc> SwitchCase<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::SwitchCase<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::SwitchCase {
                    metadata: node.metadata.duplicate(),
                    test: node.test.duplicate(),
                    consequent: node.consequent.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::SwitchCase(self.inner))
        }
        /// Set the `test` field and mark the builder changed.
        pub fn test(&mut self, test: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.test = test; }
        /// Set the `consequent` field and mark the builder changed.
        pub fn consequent(&mut self, consequent: NodeList<'gc>) { self.is_changed = true; self.inner.consequent = consequent; }
    }
    /// Clone-with-changes builder for [`super::CatchClause`].
    #[derive(Debug)]
    pub struct CatchClause<'gc> {
        is_changed: bool,
        pub(super) inner: super::CatchClause<'gc>,
    }
    impl<'gc> CatchClause<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::CatchClause<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::CatchClause {
                    metadata: node.metadata.duplicate(),
                    param: node.param.duplicate(),
                    body: node.body.duplicate(),
                    scope: Cell::new(node.scope.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::CatchClause(self.inner))
        }
        /// Set the `param` field and mark the builder changed.
        pub fn param(&mut self, param: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.param = param; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::VariableDeclarator`].
    #[derive(Debug)]
    pub struct VariableDeclarator<'gc> {
        is_changed: bool,
        pub(super) inner: super::VariableDeclarator<'gc>,
    }
    impl<'gc> VariableDeclarator<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::VariableDeclarator<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::VariableDeclarator {
                    metadata: node.metadata.duplicate(),
                    init: node.init.duplicate(),
                    id: node.id.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::VariableDeclarator(self.inner))
        }
        /// Set the `init` field and mark the builder changed.
        pub fn init(&mut self, init: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.init = init; }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
    }
    /// Clone-with-changes builder for [`super::VariableDeclaration`].
    #[derive(Debug)]
    pub struct VariableDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::VariableDeclaration<'gc>,
    }
    impl<'gc> VariableDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::VariableDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::VariableDeclaration {
                    metadata: node.metadata.duplicate(),
                    kind: Cell::new(node.kind.get()),
                    declarations: node.declarations.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::VariableDeclaration(self.inner))
        }
        /// Set the `declarations` field and mark the builder changed.
        pub fn declarations(&mut self, declarations: NodeList<'gc>) { self.is_changed = true; self.inner.declarations = declarations; }
    }
    /// Clone-with-changes builder for [`super::TemplateLiteral`].
    #[derive(Debug)]
    pub struct TemplateLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::TemplateLiteral<'gc>,
    }
    impl<'gc> TemplateLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TemplateLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TemplateLiteral {
                    metadata: node.metadata.duplicate(),
                    quasis: node.quasis.duplicate(),
                    expressions: node.expressions.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TemplateLiteral(self.inner))
        }
        /// Set the `quasis` field and mark the builder changed.
        pub fn quasis(&mut self, quasis: NodeList<'gc>) { self.is_changed = true; self.inner.quasis = quasis; }
        /// Set the `expressions` field and mark the builder changed.
        pub fn expressions(&mut self, expressions: NodeList<'gc>) { self.is_changed = true; self.inner.expressions = expressions; }
    }
    /// Clone-with-changes builder for [`super::TaggedTemplateExpression`].
    #[derive(Debug)]
    pub struct TaggedTemplateExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::TaggedTemplateExpression<'gc>,
    }
    impl<'gc> TaggedTemplateExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TaggedTemplateExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TaggedTemplateExpression {
                    metadata: node.metadata.duplicate(),
                    tag: node.tag.duplicate(),
                    quasi: node.quasi.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TaggedTemplateExpression(self.inner))
        }
        /// Set the `tag` field and mark the builder changed.
        pub fn tag(&mut self, tag: &'gc Node<'gc>) { self.is_changed = true; self.inner.tag = tag; }
        /// Set the `quasi` field and mark the builder changed.
        pub fn quasi(&mut self, quasi: &'gc Node<'gc>) { self.is_changed = true; self.inner.quasi = quasi; }
    }
    /// Clone-with-changes builder for [`super::TemplateElement`].
    #[derive(Debug)]
    pub struct TemplateElement<'gc> {
        is_changed: bool,
        pub(super) inner: super::TemplateElement<'gc>,
    }
    impl<'gc> TemplateElement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TemplateElement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TemplateElement {
                    metadata: node.metadata.duplicate(),
                    tail: Cell::new(node.tail.get()),
                    cooked: Cell::new(node.cooked.get()),
                    raw: Cell::new(node.raw.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TemplateElement(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::Property`].
    #[derive(Debug)]
    pub struct Property<'gc> {
        is_changed: bool,
        pub(super) inner: super::Property<'gc>,
    }
    impl<'gc> Property<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::Property<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::Property {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    value: node.value.duplicate(),
                    kind: Cell::new(node.kind.get()),
                    computed: Cell::new(node.computed.get()),
                    method: Cell::new(node.method.get()),
                    shorthand: Cell::new(node.shorthand.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::Property(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
    }
    /// Clone-with-changes builder for [`super::Decorator`].
    #[derive(Debug)]
    pub struct Decorator<'gc> {
        is_changed: bool,
        pub(super) inner: super::Decorator<'gc>,
    }
    impl<'gc> Decorator<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::Decorator<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::Decorator {
                    metadata: node.metadata.duplicate(),
                    expression: node.expression.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::Decorator(self.inner))
        }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
    }
    /// Clone-with-changes builder for [`super::ClassDeclaration`].
    #[derive(Debug)]
    pub struct ClassDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::ClassDeclaration<'gc>,
    }
    impl<'gc> ClassDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ClassDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ClassDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    super_class: node.super_class.duplicate(),
                    super_type_arguments: node.super_type_arguments.duplicate(),
                    implements: node.implements.duplicate(),
                    decorators: node.decorators.duplicate(),
                    body: node.body.duplicate(),
                    scope: Cell::new(node.scope.get()),
                    implicit_ctor_function_info: Cell::new(node.implicit_ctor_function_info.get()),
                    instance_elements_init_function_info: Cell::new(node.instance_elements_init_function_info.get()),
                    static_elements_init_function_info: Cell::new(node.static_elements_init_function_info.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ClassDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `super_class` field and mark the builder changed.
        pub fn super_class(&mut self, super_class: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.super_class = super_class; }
        /// Set the `super_type_arguments` field and mark the builder changed.
        pub fn super_type_arguments(&mut self, super_type_arguments: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.super_type_arguments = super_type_arguments; }
        /// Set the `implements` field and mark the builder changed.
        pub fn implements(&mut self, implements: NodeList<'gc>) { self.is_changed = true; self.inner.implements = implements; }
        /// Set the `decorators` field and mark the builder changed.
        pub fn decorators(&mut self, decorators: NodeList<'gc>) { self.is_changed = true; self.inner.decorators = decorators; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::ClassExpression`].
    #[derive(Debug)]
    pub struct ClassExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::ClassExpression<'gc>,
    }
    impl<'gc> ClassExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ClassExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ClassExpression {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    super_class: node.super_class.duplicate(),
                    super_type_arguments: node.super_type_arguments.duplicate(),
                    implements: node.implements.duplicate(),
                    decorators: node.decorators.duplicate(),
                    body: node.body.duplicate(),
                    scope: Cell::new(node.scope.get()),
                    implicit_ctor_function_info: Cell::new(node.implicit_ctor_function_info.get()),
                    instance_elements_init_function_info: Cell::new(node.instance_elements_init_function_info.get()),
                    static_elements_init_function_info: Cell::new(node.static_elements_init_function_info.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ClassExpression(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `super_class` field and mark the builder changed.
        pub fn super_class(&mut self, super_class: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.super_class = super_class; }
        /// Set the `super_type_arguments` field and mark the builder changed.
        pub fn super_type_arguments(&mut self, super_type_arguments: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.super_type_arguments = super_type_arguments; }
        /// Set the `implements` field and mark the builder changed.
        pub fn implements(&mut self, implements: NodeList<'gc>) { self.is_changed = true; self.inner.implements = implements; }
        /// Set the `decorators` field and mark the builder changed.
        pub fn decorators(&mut self, decorators: NodeList<'gc>) { self.is_changed = true; self.inner.decorators = decorators; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::ClassBody`].
    #[derive(Debug)]
    pub struct ClassBody<'gc> {
        is_changed: bool,
        pub(super) inner: super::ClassBody<'gc>,
    }
    impl<'gc> ClassBody<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ClassBody<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ClassBody {
                    metadata: node.metadata.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ClassBody(self.inner))
        }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: NodeList<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::ClassProperty`].
    #[derive(Debug)]
    pub struct ClassProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::ClassProperty<'gc>,
    }
    impl<'gc> ClassProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ClassProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ClassProperty {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    value: node.value.duplicate(),
                    computed: Cell::new(node.computed.get()),
                    r#static: Cell::new(node.r#static.get()),
                    decorators: node.decorators.duplicate(),
                    declare: Cell::new(node.declare.get()),
                    optional: Cell::new(node.optional.get()),
                    variance: node.variance.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                    ts_modifiers: node.ts_modifiers.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ClassProperty(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.value = value; }
        /// Set the `decorators` field and mark the builder changed.
        pub fn decorators(&mut self, decorators: NodeList<'gc>) { self.is_changed = true; self.inner.decorators = decorators; }
        /// Set the `variance` field and mark the builder changed.
        pub fn variance(&mut self, variance: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.variance = variance; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
        /// Set the `ts_modifiers` field and mark the builder changed.
        pub fn ts_modifiers(&mut self, ts_modifiers: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.ts_modifiers = ts_modifiers; }
    }
    /// Clone-with-changes builder for [`super::ClassPrivateProperty`].
    #[derive(Debug)]
    pub struct ClassPrivateProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::ClassPrivateProperty<'gc>,
    }
    impl<'gc> ClassPrivateProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ClassPrivateProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ClassPrivateProperty {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    value: node.value.duplicate(),
                    r#static: Cell::new(node.r#static.get()),
                    decorators: node.decorators.duplicate(),
                    declare: Cell::new(node.declare.get()),
                    optional: Cell::new(node.optional.get()),
                    variance: node.variance.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                    ts_modifiers: node.ts_modifiers.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ClassPrivateProperty(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.value = value; }
        /// Set the `decorators` field and mark the builder changed.
        pub fn decorators(&mut self, decorators: NodeList<'gc>) { self.is_changed = true; self.inner.decorators = decorators; }
        /// Set the `variance` field and mark the builder changed.
        pub fn variance(&mut self, variance: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.variance = variance; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
        /// Set the `ts_modifiers` field and mark the builder changed.
        pub fn ts_modifiers(&mut self, ts_modifiers: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.ts_modifiers = ts_modifiers; }
    }
    /// Clone-with-changes builder for [`super::MethodDefinition`].
    #[derive(Debug)]
    pub struct MethodDefinition<'gc> {
        is_changed: bool,
        pub(super) inner: super::MethodDefinition<'gc>,
    }
    impl<'gc> MethodDefinition<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MethodDefinition<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MethodDefinition {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    value: node.value.duplicate(),
                    kind: Cell::new(node.kind.get()),
                    computed: Cell::new(node.computed.get()),
                    r#static: Cell::new(node.r#static.get()),
                    decorators: node.decorators.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MethodDefinition(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
        /// Set the `decorators` field and mark the builder changed.
        pub fn decorators(&mut self, decorators: NodeList<'gc>) { self.is_changed = true; self.inner.decorators = decorators; }
    }
    /// Clone-with-changes builder for [`super::ImportDeclaration`].
    #[derive(Debug)]
    pub struct ImportDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::ImportDeclaration<'gc>,
    }
    impl<'gc> ImportDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ImportDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ImportDeclaration {
                    metadata: node.metadata.duplicate(),
                    specifiers: node.specifiers.duplicate(),
                    source: node.source.duplicate(),
                    attributes: node.attributes.duplicate(),
                    import_kind: Cell::new(node.import_kind.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ImportDeclaration(self.inner))
        }
        /// Set the `specifiers` field and mark the builder changed.
        pub fn specifiers(&mut self, specifiers: NodeList<'gc>) { self.is_changed = true; self.inner.specifiers = specifiers; }
        /// Set the `source` field and mark the builder changed.
        pub fn source(&mut self, source: &'gc Node<'gc>) { self.is_changed = true; self.inner.source = source; }
        /// Set the `attributes` field and mark the builder changed.
        pub fn attributes(&mut self, attributes: NodeList<'gc>) { self.is_changed = true; self.inner.attributes = attributes; }
    }
    /// Clone-with-changes builder for [`super::ImportSpecifier`].
    #[derive(Debug)]
    pub struct ImportSpecifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::ImportSpecifier<'gc>,
    }
    impl<'gc> ImportSpecifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ImportSpecifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ImportSpecifier {
                    metadata: node.metadata.duplicate(),
                    imported: node.imported.duplicate(),
                    local: node.local.duplicate(),
                    import_kind: Cell::new(node.import_kind.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ImportSpecifier(self.inner))
        }
        /// Set the `imported` field and mark the builder changed.
        pub fn imported(&mut self, imported: &'gc Node<'gc>) { self.is_changed = true; self.inner.imported = imported; }
        /// Set the `local` field and mark the builder changed.
        pub fn local(&mut self, local: &'gc Node<'gc>) { self.is_changed = true; self.inner.local = local; }
    }
    /// Clone-with-changes builder for [`super::ImportDefaultSpecifier`].
    #[derive(Debug)]
    pub struct ImportDefaultSpecifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::ImportDefaultSpecifier<'gc>,
    }
    impl<'gc> ImportDefaultSpecifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ImportDefaultSpecifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ImportDefaultSpecifier {
                    metadata: node.metadata.duplicate(),
                    local: node.local.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ImportDefaultSpecifier(self.inner))
        }
        /// Set the `local` field and mark the builder changed.
        pub fn local(&mut self, local: &'gc Node<'gc>) { self.is_changed = true; self.inner.local = local; }
    }
    /// Clone-with-changes builder for [`super::ImportNamespaceSpecifier`].
    #[derive(Debug)]
    pub struct ImportNamespaceSpecifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::ImportNamespaceSpecifier<'gc>,
    }
    impl<'gc> ImportNamespaceSpecifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ImportNamespaceSpecifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ImportNamespaceSpecifier {
                    metadata: node.metadata.duplicate(),
                    local: node.local.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ImportNamespaceSpecifier(self.inner))
        }
        /// Set the `local` field and mark the builder changed.
        pub fn local(&mut self, local: &'gc Node<'gc>) { self.is_changed = true; self.inner.local = local; }
    }
    /// Clone-with-changes builder for [`super::ImportAttribute`].
    #[derive(Debug)]
    pub struct ImportAttribute<'gc> {
        is_changed: bool,
        pub(super) inner: super::ImportAttribute<'gc>,
    }
    impl<'gc> ImportAttribute<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ImportAttribute<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ImportAttribute {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    value: node.value.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ImportAttribute(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
    }
    /// Clone-with-changes builder for [`super::ExportNamedDeclaration`].
    #[derive(Debug)]
    pub struct ExportNamedDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::ExportNamedDeclaration<'gc>,
    }
    impl<'gc> ExportNamedDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ExportNamedDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ExportNamedDeclaration {
                    metadata: node.metadata.duplicate(),
                    declaration: node.declaration.duplicate(),
                    specifiers: node.specifiers.duplicate(),
                    source: node.source.duplicate(),
                    export_kind: Cell::new(node.export_kind.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ExportNamedDeclaration(self.inner))
        }
        /// Set the `declaration` field and mark the builder changed.
        pub fn declaration(&mut self, declaration: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.declaration = declaration; }
        /// Set the `specifiers` field and mark the builder changed.
        pub fn specifiers(&mut self, specifiers: NodeList<'gc>) { self.is_changed = true; self.inner.specifiers = specifiers; }
        /// Set the `source` field and mark the builder changed.
        pub fn source(&mut self, source: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.source = source; }
    }
    /// Clone-with-changes builder for [`super::ExportSpecifier`].
    #[derive(Debug)]
    pub struct ExportSpecifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::ExportSpecifier<'gc>,
    }
    impl<'gc> ExportSpecifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ExportSpecifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ExportSpecifier {
                    metadata: node.metadata.duplicate(),
                    exported: node.exported.duplicate(),
                    local: node.local.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ExportSpecifier(self.inner))
        }
        /// Set the `exported` field and mark the builder changed.
        pub fn exported(&mut self, exported: &'gc Node<'gc>) { self.is_changed = true; self.inner.exported = exported; }
        /// Set the `local` field and mark the builder changed.
        pub fn local(&mut self, local: &'gc Node<'gc>) { self.is_changed = true; self.inner.local = local; }
    }
    /// Clone-with-changes builder for [`super::ExportNamespaceSpecifier`].
    #[derive(Debug)]
    pub struct ExportNamespaceSpecifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::ExportNamespaceSpecifier<'gc>,
    }
    impl<'gc> ExportNamespaceSpecifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ExportNamespaceSpecifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ExportNamespaceSpecifier {
                    metadata: node.metadata.duplicate(),
                    exported: node.exported.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ExportNamespaceSpecifier(self.inner))
        }
        /// Set the `exported` field and mark the builder changed.
        pub fn exported(&mut self, exported: &'gc Node<'gc>) { self.is_changed = true; self.inner.exported = exported; }
    }
    /// Clone-with-changes builder for [`super::ExportDefaultDeclaration`].
    #[derive(Debug)]
    pub struct ExportDefaultDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::ExportDefaultDeclaration<'gc>,
    }
    impl<'gc> ExportDefaultDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ExportDefaultDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ExportDefaultDeclaration {
                    metadata: node.metadata.duplicate(),
                    declaration: node.declaration.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ExportDefaultDeclaration(self.inner))
        }
        /// Set the `declaration` field and mark the builder changed.
        pub fn declaration(&mut self, declaration: &'gc Node<'gc>) { self.is_changed = true; self.inner.declaration = declaration; }
    }
    /// Clone-with-changes builder for [`super::ExportAllDeclaration`].
    #[derive(Debug)]
    pub struct ExportAllDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::ExportAllDeclaration<'gc>,
    }
    impl<'gc> ExportAllDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ExportAllDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ExportAllDeclaration {
                    metadata: node.metadata.duplicate(),
                    source: node.source.duplicate(),
                    export_kind: Cell::new(node.export_kind.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ExportAllDeclaration(self.inner))
        }
        /// Set the `source` field and mark the builder changed.
        pub fn source(&mut self, source: &'gc Node<'gc>) { self.is_changed = true; self.inner.source = source; }
    }
    /// Clone-with-changes builder for [`super::ObjectPattern`].
    #[derive(Debug)]
    pub struct ObjectPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::ObjectPattern<'gc>,
    }
    impl<'gc> ObjectPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ObjectPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ObjectPattern {
                    metadata: node.metadata.duplicate(),
                    properties: node.properties.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ObjectPattern(self.inner))
        }
        /// Set the `properties` field and mark the builder changed.
        pub fn properties(&mut self, properties: NodeList<'gc>) { self.is_changed = true; self.inner.properties = properties; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::ArrayPattern`].
    #[derive(Debug)]
    pub struct ArrayPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::ArrayPattern<'gc>,
    }
    impl<'gc> ArrayPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ArrayPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ArrayPattern {
                    metadata: node.metadata.duplicate(),
                    elements: node.elements.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ArrayPattern(self.inner))
        }
        /// Set the `elements` field and mark the builder changed.
        pub fn elements(&mut self, elements: NodeList<'gc>) { self.is_changed = true; self.inner.elements = elements; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::RestElement`].
    #[derive(Debug)]
    pub struct RestElement<'gc> {
        is_changed: bool,
        pub(super) inner: super::RestElement<'gc>,
    }
    impl<'gc> RestElement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::RestElement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::RestElement {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::RestElement(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::AssignmentPattern`].
    #[derive(Debug)]
    pub struct AssignmentPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::AssignmentPattern<'gc>,
    }
    impl<'gc> AssignmentPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::AssignmentPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::AssignmentPattern {
                    metadata: node.metadata.duplicate(),
                    left: node.left.duplicate(),
                    right: node.right.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::AssignmentPattern(self.inner))
        }
        /// Set the `left` field and mark the builder changed.
        pub fn left(&mut self, left: &'gc Node<'gc>) { self.is_changed = true; self.inner.left = left; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: &'gc Node<'gc>) { self.is_changed = true; self.inner.right = right; }
    }
    /// Clone-with-changes builder for [`super::MatchStatementCase`].
    #[derive(Debug)]
    pub struct MatchStatementCase<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchStatementCase<'gc>,
    }
    impl<'gc> MatchStatementCase<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchStatementCase<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchStatementCase {
                    metadata: node.metadata.duplicate(),
                    pattern: node.pattern.duplicate(),
                    body: node.body.duplicate(),
                    guard: node.guard.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchStatementCase(self.inner))
        }
        /// Set the `pattern` field and mark the builder changed.
        pub fn pattern(&mut self, pattern: &'gc Node<'gc>) { self.is_changed = true; self.inner.pattern = pattern; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `guard` field and mark the builder changed.
        pub fn guard(&mut self, guard: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.guard = guard; }
    }
    /// Clone-with-changes builder for [`super::MatchExpression`].
    #[derive(Debug)]
    pub struct MatchExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchExpression<'gc>,
    }
    impl<'gc> MatchExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchExpression {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                    cases: node.cases.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchExpression(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
        /// Set the `cases` field and mark the builder changed.
        pub fn cases(&mut self, cases: NodeList<'gc>) { self.is_changed = true; self.inner.cases = cases; }
    }
    /// Clone-with-changes builder for [`super::MatchExpressionCase`].
    #[derive(Debug)]
    pub struct MatchExpressionCase<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchExpressionCase<'gc>,
    }
    impl<'gc> MatchExpressionCase<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchExpressionCase<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchExpressionCase {
                    metadata: node.metadata.duplicate(),
                    pattern: node.pattern.duplicate(),
                    body: node.body.duplicate(),
                    guard: node.guard.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchExpressionCase(self.inner))
        }
        /// Set the `pattern` field and mark the builder changed.
        pub fn pattern(&mut self, pattern: &'gc Node<'gc>) { self.is_changed = true; self.inner.pattern = pattern; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `guard` field and mark the builder changed.
        pub fn guard(&mut self, guard: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.guard = guard; }
    }
    /// Clone-with-changes builder for [`super::MatchWildcardPattern`].
    #[derive(Debug)]
    pub struct MatchWildcardPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchWildcardPattern<'gc>,
    }
    impl<'gc> MatchWildcardPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchWildcardPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchWildcardPattern {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchWildcardPattern(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::MatchLiteralPattern`].
    #[derive(Debug)]
    pub struct MatchLiteralPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchLiteralPattern<'gc>,
    }
    impl<'gc> MatchLiteralPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchLiteralPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchLiteralPattern {
                    metadata: node.metadata.duplicate(),
                    literal: node.literal.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchLiteralPattern(self.inner))
        }
        /// Set the `literal` field and mark the builder changed.
        pub fn literal(&mut self, literal: &'gc Node<'gc>) { self.is_changed = true; self.inner.literal = literal; }
    }
    /// Clone-with-changes builder for [`super::MatchUnaryPattern`].
    #[derive(Debug)]
    pub struct MatchUnaryPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchUnaryPattern<'gc>,
    }
    impl<'gc> MatchUnaryPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchUnaryPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchUnaryPattern {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                    operator: Cell::new(node.operator.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchUnaryPattern(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::MatchIdentifierPattern`].
    #[derive(Debug)]
    pub struct MatchIdentifierPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchIdentifierPattern<'gc>,
    }
    impl<'gc> MatchIdentifierPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchIdentifierPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchIdentifierPattern {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchIdentifierPattern(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
    }
    /// Clone-with-changes builder for [`super::MatchBindingPattern`].
    #[derive(Debug)]
    pub struct MatchBindingPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchBindingPattern<'gc>,
    }
    impl<'gc> MatchBindingPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchBindingPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchBindingPattern {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    kind: Cell::new(node.kind.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchBindingPattern(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
    }
    /// Clone-with-changes builder for [`super::MatchObjectPattern`].
    #[derive(Debug)]
    pub struct MatchObjectPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchObjectPattern<'gc>,
    }
    impl<'gc> MatchObjectPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchObjectPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchObjectPattern {
                    metadata: node.metadata.duplicate(),
                    properties: node.properties.duplicate(),
                    rest: node.rest.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchObjectPattern(self.inner))
        }
        /// Set the `properties` field and mark the builder changed.
        pub fn properties(&mut self, properties: NodeList<'gc>) { self.is_changed = true; self.inner.properties = properties; }
        /// Set the `rest` field and mark the builder changed.
        pub fn rest(&mut self, rest: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.rest = rest; }
    }
    /// Clone-with-changes builder for [`super::MatchArrayPattern`].
    #[derive(Debug)]
    pub struct MatchArrayPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchArrayPattern<'gc>,
    }
    impl<'gc> MatchArrayPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchArrayPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchArrayPattern {
                    metadata: node.metadata.duplicate(),
                    elements: node.elements.duplicate(),
                    rest: node.rest.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchArrayPattern(self.inner))
        }
        /// Set the `elements` field and mark the builder changed.
        pub fn elements(&mut self, elements: NodeList<'gc>) { self.is_changed = true; self.inner.elements = elements; }
        /// Set the `rest` field and mark the builder changed.
        pub fn rest(&mut self, rest: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.rest = rest; }
    }
    /// Clone-with-changes builder for [`super::MatchOrPattern`].
    #[derive(Debug)]
    pub struct MatchOrPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchOrPattern<'gc>,
    }
    impl<'gc> MatchOrPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchOrPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchOrPattern {
                    metadata: node.metadata.duplicate(),
                    patterns: node.patterns.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchOrPattern(self.inner))
        }
        /// Set the `patterns` field and mark the builder changed.
        pub fn patterns(&mut self, patterns: NodeList<'gc>) { self.is_changed = true; self.inner.patterns = patterns; }
    }
    /// Clone-with-changes builder for [`super::MatchAsPattern`].
    #[derive(Debug)]
    pub struct MatchAsPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchAsPattern<'gc>,
    }
    impl<'gc> MatchAsPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchAsPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchAsPattern {
                    metadata: node.metadata.duplicate(),
                    pattern: node.pattern.duplicate(),
                    target: node.target.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchAsPattern(self.inner))
        }
        /// Set the `pattern` field and mark the builder changed.
        pub fn pattern(&mut self, pattern: &'gc Node<'gc>) { self.is_changed = true; self.inner.pattern = pattern; }
        /// Set the `target` field and mark the builder changed.
        pub fn target(&mut self, target: &'gc Node<'gc>) { self.is_changed = true; self.inner.target = target; }
    }
    /// Clone-with-changes builder for [`super::MatchMemberPattern`].
    #[derive(Debug)]
    pub struct MatchMemberPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchMemberPattern<'gc>,
    }
    impl<'gc> MatchMemberPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchMemberPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchMemberPattern {
                    metadata: node.metadata.duplicate(),
                    base: node.base.duplicate(),
                    property: node.property.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchMemberPattern(self.inner))
        }
        /// Set the `base` field and mark the builder changed.
        pub fn base(&mut self, base: &'gc Node<'gc>) { self.is_changed = true; self.inner.base = base; }
        /// Set the `property` field and mark the builder changed.
        pub fn property(&mut self, property: &'gc Node<'gc>) { self.is_changed = true; self.inner.property = property; }
    }
    /// Clone-with-changes builder for [`super::MatchInstancePattern`].
    #[derive(Debug)]
    pub struct MatchInstancePattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchInstancePattern<'gc>,
    }
    impl<'gc> MatchInstancePattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchInstancePattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchInstancePattern {
                    metadata: node.metadata.duplicate(),
                    target_constructor: node.target_constructor.duplicate(),
                    properties: node.properties.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchInstancePattern(self.inner))
        }
        /// Set the `target_constructor` field and mark the builder changed.
        pub fn target_constructor(&mut self, target_constructor: &'gc Node<'gc>) { self.is_changed = true; self.inner.target_constructor = target_constructor; }
        /// Set the `properties` field and mark the builder changed.
        pub fn properties(&mut self, properties: &'gc Node<'gc>) { self.is_changed = true; self.inner.properties = properties; }
    }
    /// Clone-with-changes builder for [`super::MatchObjectPatternProperty`].
    #[derive(Debug)]
    pub struct MatchObjectPatternProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchObjectPatternProperty<'gc>,
    }
    impl<'gc> MatchObjectPatternProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchObjectPatternProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchObjectPatternProperty {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    pattern: node.pattern.duplicate(),
                    shorthand: Cell::new(node.shorthand.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchObjectPatternProperty(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `pattern` field and mark the builder changed.
        pub fn pattern(&mut self, pattern: &'gc Node<'gc>) { self.is_changed = true; self.inner.pattern = pattern; }
    }
    /// Clone-with-changes builder for [`super::MatchInstanceObjectPattern`].
    #[derive(Debug)]
    pub struct MatchInstanceObjectPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchInstanceObjectPattern<'gc>,
    }
    impl<'gc> MatchInstanceObjectPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchInstanceObjectPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchInstanceObjectPattern {
                    metadata: node.metadata.duplicate(),
                    properties: node.properties.duplicate(),
                    rest: node.rest.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchInstanceObjectPattern(self.inner))
        }
        /// Set the `properties` field and mark the builder changed.
        pub fn properties(&mut self, properties: NodeList<'gc>) { self.is_changed = true; self.inner.properties = properties; }
        /// Set the `rest` field and mark the builder changed.
        pub fn rest(&mut self, rest: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.rest = rest; }
    }
    /// Clone-with-changes builder for [`super::MatchRestPattern`].
    #[derive(Debug)]
    pub struct MatchRestPattern<'gc> {
        is_changed: bool,
        pub(super) inner: super::MatchRestPattern<'gc>,
    }
    impl<'gc> MatchRestPattern<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MatchRestPattern<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MatchRestPattern {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MatchRestPattern(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::JSXIdentifier`].
    #[derive(Debug)]
    pub struct JSXIdentifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXIdentifier<'gc>,
    }
    impl<'gc> JSXIdentifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXIdentifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXIdentifier {
                    metadata: node.metadata.duplicate(),
                    name: Cell::new(node.name.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXIdentifier(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::JSXMemberExpression`].
    #[derive(Debug)]
    pub struct JSXMemberExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXMemberExpression<'gc>,
    }
    impl<'gc> JSXMemberExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXMemberExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXMemberExpression {
                    metadata: node.metadata.duplicate(),
                    object: node.object.duplicate(),
                    property: node.property.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXMemberExpression(self.inner))
        }
        /// Set the `object` field and mark the builder changed.
        pub fn object(&mut self, object: &'gc Node<'gc>) { self.is_changed = true; self.inner.object = object; }
        /// Set the `property` field and mark the builder changed.
        pub fn property(&mut self, property: &'gc Node<'gc>) { self.is_changed = true; self.inner.property = property; }
    }
    /// Clone-with-changes builder for [`super::JSXNamespacedName`].
    #[derive(Debug)]
    pub struct JSXNamespacedName<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXNamespacedName<'gc>,
    }
    impl<'gc> JSXNamespacedName<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXNamespacedName<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXNamespacedName {
                    metadata: node.metadata.duplicate(),
                    namespace: node.namespace.duplicate(),
                    name: node.name.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXNamespacedName(self.inner))
        }
        /// Set the `namespace` field and mark the builder changed.
        pub fn namespace(&mut self, namespace: &'gc Node<'gc>) { self.is_changed = true; self.inner.namespace = namespace; }
        /// Set the `name` field and mark the builder changed.
        pub fn name(&mut self, name: &'gc Node<'gc>) { self.is_changed = true; self.inner.name = name; }
    }
    /// Clone-with-changes builder for [`super::JSXEmptyExpression`].
    #[derive(Debug)]
    pub struct JSXEmptyExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXEmptyExpression<'gc>,
    }
    impl<'gc> JSXEmptyExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXEmptyExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXEmptyExpression {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXEmptyExpression(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::JSXExpressionContainer`].
    #[derive(Debug)]
    pub struct JSXExpressionContainer<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXExpressionContainer<'gc>,
    }
    impl<'gc> JSXExpressionContainer<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXExpressionContainer<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXExpressionContainer {
                    metadata: node.metadata.duplicate(),
                    expression: node.expression.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXExpressionContainer(self.inner))
        }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
    }
    /// Clone-with-changes builder for [`super::JSXSpreadChild`].
    #[derive(Debug)]
    pub struct JSXSpreadChild<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXSpreadChild<'gc>,
    }
    impl<'gc> JSXSpreadChild<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXSpreadChild<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXSpreadChild {
                    metadata: node.metadata.duplicate(),
                    expression: node.expression.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXSpreadChild(self.inner))
        }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
    }
    /// Clone-with-changes builder for [`super::JSXOpeningElement`].
    #[derive(Debug)]
    pub struct JSXOpeningElement<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXOpeningElement<'gc>,
    }
    impl<'gc> JSXOpeningElement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXOpeningElement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXOpeningElement {
                    metadata: node.metadata.duplicate(),
                    name: node.name.duplicate(),
                    attributes: node.attributes.duplicate(),
                    self_closing: Cell::new(node.self_closing.get()),
                    type_arguments: node.type_arguments.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXOpeningElement(self.inner))
        }
        /// Set the `name` field and mark the builder changed.
        pub fn name(&mut self, name: &'gc Node<'gc>) { self.is_changed = true; self.inner.name = name; }
        /// Set the `attributes` field and mark the builder changed.
        pub fn attributes(&mut self, attributes: NodeList<'gc>) { self.is_changed = true; self.inner.attributes = attributes; }
        /// Set the `type_arguments` field and mark the builder changed.
        pub fn type_arguments(&mut self, type_arguments: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_arguments = type_arguments; }
    }
    /// Clone-with-changes builder for [`super::JSXClosingElement`].
    #[derive(Debug)]
    pub struct JSXClosingElement<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXClosingElement<'gc>,
    }
    impl<'gc> JSXClosingElement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXClosingElement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXClosingElement {
                    metadata: node.metadata.duplicate(),
                    name: node.name.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXClosingElement(self.inner))
        }
        /// Set the `name` field and mark the builder changed.
        pub fn name(&mut self, name: &'gc Node<'gc>) { self.is_changed = true; self.inner.name = name; }
    }
    /// Clone-with-changes builder for [`super::JSXAttribute`].
    #[derive(Debug)]
    pub struct JSXAttribute<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXAttribute<'gc>,
    }
    impl<'gc> JSXAttribute<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXAttribute<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXAttribute {
                    metadata: node.metadata.duplicate(),
                    name: node.name.duplicate(),
                    value: node.value.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXAttribute(self.inner))
        }
        /// Set the `name` field and mark the builder changed.
        pub fn name(&mut self, name: &'gc Node<'gc>) { self.is_changed = true; self.inner.name = name; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.value = value; }
    }
    /// Clone-with-changes builder for [`super::JSXSpreadAttribute`].
    #[derive(Debug)]
    pub struct JSXSpreadAttribute<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXSpreadAttribute<'gc>,
    }
    impl<'gc> JSXSpreadAttribute<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXSpreadAttribute<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXSpreadAttribute {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXSpreadAttribute(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::JSXStringLiteral`].
    #[derive(Debug)]
    pub struct JSXStringLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXStringLiteral<'gc>,
    }
    impl<'gc> JSXStringLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXStringLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXStringLiteral {
                    metadata: node.metadata.duplicate(),
                    value: Cell::new(node.value.get()),
                    raw: Cell::new(node.raw.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXStringLiteral(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::JSXText`].
    #[derive(Debug)]
    pub struct JSXText<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXText<'gc>,
    }
    impl<'gc> JSXText<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXText<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXText {
                    metadata: node.metadata.duplicate(),
                    value: Cell::new(node.value.get()),
                    raw: Cell::new(node.raw.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXText(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::JSXElement`].
    #[derive(Debug)]
    pub struct JSXElement<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXElement<'gc>,
    }
    impl<'gc> JSXElement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXElement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXElement {
                    metadata: node.metadata.duplicate(),
                    opening_element: node.opening_element.duplicate(),
                    children: node.children.duplicate(),
                    closing_element: node.closing_element.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXElement(self.inner))
        }
        /// Set the `opening_element` field and mark the builder changed.
        pub fn opening_element(&mut self, opening_element: &'gc Node<'gc>) { self.is_changed = true; self.inner.opening_element = opening_element; }
        /// Set the `children` field and mark the builder changed.
        pub fn children(&mut self, children: NodeList<'gc>) { self.is_changed = true; self.inner.children = children; }
        /// Set the `closing_element` field and mark the builder changed.
        pub fn closing_element(&mut self, closing_element: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.closing_element = closing_element; }
    }
    /// Clone-with-changes builder for [`super::JSXFragment`].
    #[derive(Debug)]
    pub struct JSXFragment<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXFragment<'gc>,
    }
    impl<'gc> JSXFragment<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXFragment<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXFragment {
                    metadata: node.metadata.duplicate(),
                    opening_fragment: node.opening_fragment.duplicate(),
                    children: node.children.duplicate(),
                    closing_fragment: node.closing_fragment.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXFragment(self.inner))
        }
        /// Set the `opening_fragment` field and mark the builder changed.
        pub fn opening_fragment(&mut self, opening_fragment: &'gc Node<'gc>) { self.is_changed = true; self.inner.opening_fragment = opening_fragment; }
        /// Set the `children` field and mark the builder changed.
        pub fn children(&mut self, children: NodeList<'gc>) { self.is_changed = true; self.inner.children = children; }
        /// Set the `closing_fragment` field and mark the builder changed.
        pub fn closing_fragment(&mut self, closing_fragment: &'gc Node<'gc>) { self.is_changed = true; self.inner.closing_fragment = closing_fragment; }
    }
    /// Clone-with-changes builder for [`super::JSXOpeningFragment`].
    #[derive(Debug)]
    pub struct JSXOpeningFragment<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXOpeningFragment<'gc>,
    }
    impl<'gc> JSXOpeningFragment<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXOpeningFragment<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXOpeningFragment {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXOpeningFragment(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::JSXClosingFragment`].
    #[derive(Debug)]
    pub struct JSXClosingFragment<'gc> {
        is_changed: bool,
        pub(super) inner: super::JSXClosingFragment<'gc>,
    }
    impl<'gc> JSXClosingFragment<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::JSXClosingFragment<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::JSXClosingFragment {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::JSXClosingFragment(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::ExistsTypeAnnotation`].
    #[derive(Debug)]
    pub struct ExistsTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::ExistsTypeAnnotation<'gc>,
    }
    impl<'gc> ExistsTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ExistsTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ExistsTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ExistsTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::EmptyTypeAnnotation`].
    #[derive(Debug)]
    pub struct EmptyTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::EmptyTypeAnnotation<'gc>,
    }
    impl<'gc> EmptyTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EmptyTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EmptyTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EmptyTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::StringTypeAnnotation`].
    #[derive(Debug)]
    pub struct StringTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::StringTypeAnnotation<'gc>,
    }
    impl<'gc> StringTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::StringTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::StringTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::StringTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::NumberTypeAnnotation`].
    #[derive(Debug)]
    pub struct NumberTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::NumberTypeAnnotation<'gc>,
    }
    impl<'gc> NumberTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::NumberTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::NumberTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::NumberTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::StringLiteralTypeAnnotation`].
    #[derive(Debug)]
    pub struct StringLiteralTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::StringLiteralTypeAnnotation<'gc>,
    }
    impl<'gc> StringLiteralTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::StringLiteralTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::StringLiteralTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    value: Cell::new(node.value.get()),
                    raw: Cell::new(node.raw.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::StringLiteralTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::NumberLiteralTypeAnnotation`].
    #[derive(Debug)]
    pub struct NumberLiteralTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::NumberLiteralTypeAnnotation<'gc>,
    }
    impl<'gc> NumberLiteralTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::NumberLiteralTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::NumberLiteralTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    value: Cell::new(node.value.get()),
                    raw: Cell::new(node.raw.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::NumberLiteralTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::BigIntLiteralTypeAnnotation`].
    #[derive(Debug)]
    pub struct BigIntLiteralTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::BigIntLiteralTypeAnnotation<'gc>,
    }
    impl<'gc> BigIntLiteralTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::BigIntLiteralTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::BigIntLiteralTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    raw: Cell::new(node.raw.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::BigIntLiteralTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::BooleanTypeAnnotation`].
    #[derive(Debug)]
    pub struct BooleanTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::BooleanTypeAnnotation<'gc>,
    }
    impl<'gc> BooleanTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::BooleanTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::BooleanTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::BooleanTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::BooleanLiteralTypeAnnotation`].
    #[derive(Debug)]
    pub struct BooleanLiteralTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::BooleanLiteralTypeAnnotation<'gc>,
    }
    impl<'gc> BooleanLiteralTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::BooleanLiteralTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::BooleanLiteralTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    value: Cell::new(node.value.get()),
                    raw: Cell::new(node.raw.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::BooleanLiteralTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::NullLiteralTypeAnnotation`].
    #[derive(Debug)]
    pub struct NullLiteralTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::NullLiteralTypeAnnotation<'gc>,
    }
    impl<'gc> NullLiteralTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::NullLiteralTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::NullLiteralTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::NullLiteralTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::SymbolTypeAnnotation`].
    #[derive(Debug)]
    pub struct SymbolTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::SymbolTypeAnnotation<'gc>,
    }
    impl<'gc> SymbolTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::SymbolTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::SymbolTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::SymbolTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::AnyTypeAnnotation`].
    #[derive(Debug)]
    pub struct AnyTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::AnyTypeAnnotation<'gc>,
    }
    impl<'gc> AnyTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::AnyTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::AnyTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::AnyTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::MixedTypeAnnotation`].
    #[derive(Debug)]
    pub struct MixedTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::MixedTypeAnnotation<'gc>,
    }
    impl<'gc> MixedTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::MixedTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::MixedTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::MixedTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::BigIntTypeAnnotation`].
    #[derive(Debug)]
    pub struct BigIntTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::BigIntTypeAnnotation<'gc>,
    }
    impl<'gc> BigIntTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::BigIntTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::BigIntTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::BigIntTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::VoidTypeAnnotation`].
    #[derive(Debug)]
    pub struct VoidTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::VoidTypeAnnotation<'gc>,
    }
    impl<'gc> VoidTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::VoidTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::VoidTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::VoidTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::NeverTypeAnnotation`].
    #[derive(Debug)]
    pub struct NeverTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::NeverTypeAnnotation<'gc>,
    }
    impl<'gc> NeverTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::NeverTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::NeverTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::NeverTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::UnknownTypeAnnotation`].
    #[derive(Debug)]
    pub struct UnknownTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::UnknownTypeAnnotation<'gc>,
    }
    impl<'gc> UnknownTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::UnknownTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::UnknownTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::UnknownTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::UndefinedTypeAnnotation`].
    #[derive(Debug)]
    pub struct UndefinedTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::UndefinedTypeAnnotation<'gc>,
    }
    impl<'gc> UndefinedTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::UndefinedTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::UndefinedTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::UndefinedTypeAnnotation(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::FunctionTypeAnnotation`].
    #[derive(Debug)]
    pub struct FunctionTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::FunctionTypeAnnotation<'gc>,
    }
    impl<'gc> FunctionTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::FunctionTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::FunctionTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                    this: node.this.duplicate(),
                    return_type: node.return_type.duplicate(),
                    rest: node.rest.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::FunctionTypeAnnotation(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `this` field and mark the builder changed.
        pub fn this(&mut self, this: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.this = this; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.return_type = return_type; }
        /// Set the `rest` field and mark the builder changed.
        pub fn rest(&mut self, rest: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.rest = rest; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::HookTypeAnnotation`].
    #[derive(Debug)]
    pub struct HookTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::HookTypeAnnotation<'gc>,
    }
    impl<'gc> HookTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::HookTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::HookTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                    return_type: node.return_type.duplicate(),
                    rest: node.rest.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::HookTypeAnnotation(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.return_type = return_type; }
        /// Set the `rest` field and mark the builder changed.
        pub fn rest(&mut self, rest: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.rest = rest; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::FunctionTypeParam`].
    #[derive(Debug)]
    pub struct FunctionTypeParam<'gc> {
        is_changed: bool,
        pub(super) inner: super::FunctionTypeParam<'gc>,
    }
    impl<'gc> FunctionTypeParam<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::FunctionTypeParam<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::FunctionTypeParam {
                    metadata: node.metadata.duplicate(),
                    name: node.name.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                    optional: Cell::new(node.optional.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::FunctionTypeParam(self.inner))
        }
        /// Set the `name` field and mark the builder changed.
        pub fn name(&mut self, name: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.name = name; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::ComponentTypeAnnotation`].
    #[derive(Debug)]
    pub struct ComponentTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::ComponentTypeAnnotation<'gc>,
    }
    impl<'gc> ComponentTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ComponentTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ComponentTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                    rest: node.rest.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    renders_type: node.renders_type.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ComponentTypeAnnotation(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `rest` field and mark the builder changed.
        pub fn rest(&mut self, rest: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.rest = rest; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `renders_type` field and mark the builder changed.
        pub fn renders_type(&mut self, renders_type: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.renders_type = renders_type; }
    }
    /// Clone-with-changes builder for [`super::ComponentTypeParameter`].
    #[derive(Debug)]
    pub struct ComponentTypeParameter<'gc> {
        is_changed: bool,
        pub(super) inner: super::ComponentTypeParameter<'gc>,
    }
    impl<'gc> ComponentTypeParameter<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ComponentTypeParameter<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ComponentTypeParameter {
                    metadata: node.metadata.duplicate(),
                    name: node.name.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                    optional: Cell::new(node.optional.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ComponentTypeParameter(self.inner))
        }
        /// Set the `name` field and mark the builder changed.
        pub fn name(&mut self, name: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.name = name; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::NullableTypeAnnotation`].
    #[derive(Debug)]
    pub struct NullableTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::NullableTypeAnnotation<'gc>,
    }
    impl<'gc> NullableTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::NullableTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::NullableTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::NullableTypeAnnotation(self.inner))
        }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::QualifiedTypeIdentifier`].
    #[derive(Debug)]
    pub struct QualifiedTypeIdentifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::QualifiedTypeIdentifier<'gc>,
    }
    impl<'gc> QualifiedTypeIdentifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::QualifiedTypeIdentifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::QualifiedTypeIdentifier {
                    metadata: node.metadata.duplicate(),
                    qualification: node.qualification.duplicate(),
                    id: node.id.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::QualifiedTypeIdentifier(self.inner))
        }
        /// Set the `qualification` field and mark the builder changed.
        pub fn qualification(&mut self, qualification: &'gc Node<'gc>) { self.is_changed = true; self.inner.qualification = qualification; }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
    }
    /// Clone-with-changes builder for [`super::TypeofTypeAnnotation`].
    #[derive(Debug)]
    pub struct TypeofTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::TypeofTypeAnnotation<'gc>,
    }
    impl<'gc> TypeofTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TypeofTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TypeofTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                    type_arguments: node.type_arguments.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TypeofTypeAnnotation(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
        /// Set the `type_arguments` field and mark the builder changed.
        pub fn type_arguments(&mut self, type_arguments: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_arguments = type_arguments; }
    }
    /// Clone-with-changes builder for [`super::KeyofTypeAnnotation`].
    #[derive(Debug)]
    pub struct KeyofTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::KeyofTypeAnnotation<'gc>,
    }
    impl<'gc> KeyofTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::KeyofTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::KeyofTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::KeyofTypeAnnotation(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::TypeOperator`].
    #[derive(Debug)]
    pub struct TypeOperator<'gc> {
        is_changed: bool,
        pub(super) inner: super::TypeOperator<'gc>,
    }
    impl<'gc> TypeOperator<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TypeOperator<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TypeOperator {
                    metadata: node.metadata.duplicate(),
                    operator: Cell::new(node.operator.get()),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TypeOperator(self.inner))
        }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::QualifiedTypeofIdentifier`].
    #[derive(Debug)]
    pub struct QualifiedTypeofIdentifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::QualifiedTypeofIdentifier<'gc>,
    }
    impl<'gc> QualifiedTypeofIdentifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::QualifiedTypeofIdentifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::QualifiedTypeofIdentifier {
                    metadata: node.metadata.duplicate(),
                    qualification: node.qualification.duplicate(),
                    id: node.id.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::QualifiedTypeofIdentifier(self.inner))
        }
        /// Set the `qualification` field and mark the builder changed.
        pub fn qualification(&mut self, qualification: &'gc Node<'gc>) { self.is_changed = true; self.inner.qualification = qualification; }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
    }
    /// Clone-with-changes builder for [`super::TupleTypeAnnotation`].
    #[derive(Debug)]
    pub struct TupleTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::TupleTypeAnnotation<'gc>,
    }
    impl<'gc> TupleTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TupleTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TupleTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    element_types: node.element_types.duplicate(),
                    inexact: Cell::new(node.inexact.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TupleTypeAnnotation(self.inner))
        }
        /// Set the `element_types` field and mark the builder changed.
        pub fn element_types(&mut self, element_types: NodeList<'gc>) { self.is_changed = true; self.inner.element_types = element_types; }
    }
    /// Clone-with-changes builder for [`super::TupleTypeSpreadElement`].
    #[derive(Debug)]
    pub struct TupleTypeSpreadElement<'gc> {
        is_changed: bool,
        pub(super) inner: super::TupleTypeSpreadElement<'gc>,
    }
    impl<'gc> TupleTypeSpreadElement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TupleTypeSpreadElement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TupleTypeSpreadElement {
                    metadata: node.metadata.duplicate(),
                    label: node.label.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TupleTypeSpreadElement(self.inner))
        }
        /// Set the `label` field and mark the builder changed.
        pub fn label(&mut self, label: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.label = label; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::TupleTypeLabeledElement`].
    #[derive(Debug)]
    pub struct TupleTypeLabeledElement<'gc> {
        is_changed: bool,
        pub(super) inner: super::TupleTypeLabeledElement<'gc>,
    }
    impl<'gc> TupleTypeLabeledElement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TupleTypeLabeledElement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TupleTypeLabeledElement {
                    metadata: node.metadata.duplicate(),
                    label: node.label.duplicate(),
                    element_type: node.element_type.duplicate(),
                    optional: Cell::new(node.optional.get()),
                    variance: node.variance.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TupleTypeLabeledElement(self.inner))
        }
        /// Set the `label` field and mark the builder changed.
        pub fn label(&mut self, label: &'gc Node<'gc>) { self.is_changed = true; self.inner.label = label; }
        /// Set the `element_type` field and mark the builder changed.
        pub fn element_type(&mut self, element_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.element_type = element_type; }
        /// Set the `variance` field and mark the builder changed.
        pub fn variance(&mut self, variance: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.variance = variance; }
    }
    /// Clone-with-changes builder for [`super::ArrayTypeAnnotation`].
    #[derive(Debug)]
    pub struct ArrayTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::ArrayTypeAnnotation<'gc>,
    }
    impl<'gc> ArrayTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ArrayTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ArrayTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    element_type: node.element_type.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ArrayTypeAnnotation(self.inner))
        }
        /// Set the `element_type` field and mark the builder changed.
        pub fn element_type(&mut self, element_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.element_type = element_type; }
    }
    /// Clone-with-changes builder for [`super::InferTypeAnnotation`].
    #[derive(Debug)]
    pub struct InferTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::InferTypeAnnotation<'gc>,
    }
    impl<'gc> InferTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::InferTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::InferTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    type_parameter: node.type_parameter.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::InferTypeAnnotation(self.inner))
        }
        /// Set the `type_parameter` field and mark the builder changed.
        pub fn type_parameter(&mut self, type_parameter: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_parameter = type_parameter; }
    }
    /// Clone-with-changes builder for [`super::UnionTypeAnnotation`].
    #[derive(Debug)]
    pub struct UnionTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::UnionTypeAnnotation<'gc>,
    }
    impl<'gc> UnionTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::UnionTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::UnionTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    types: node.types.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::UnionTypeAnnotation(self.inner))
        }
        /// Set the `types` field and mark the builder changed.
        pub fn types(&mut self, types: NodeList<'gc>) { self.is_changed = true; self.inner.types = types; }
    }
    /// Clone-with-changes builder for [`super::IntersectionTypeAnnotation`].
    #[derive(Debug)]
    pub struct IntersectionTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::IntersectionTypeAnnotation<'gc>,
    }
    impl<'gc> IntersectionTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::IntersectionTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::IntersectionTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    types: node.types.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::IntersectionTypeAnnotation(self.inner))
        }
        /// Set the `types` field and mark the builder changed.
        pub fn types(&mut self, types: NodeList<'gc>) { self.is_changed = true; self.inner.types = types; }
    }
    /// Clone-with-changes builder for [`super::GenericTypeAnnotation`].
    #[derive(Debug)]
    pub struct GenericTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::GenericTypeAnnotation<'gc>,
    }
    impl<'gc> GenericTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::GenericTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::GenericTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::GenericTypeAnnotation(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::IndexedAccessType`].
    #[derive(Debug)]
    pub struct IndexedAccessType<'gc> {
        is_changed: bool,
        pub(super) inner: super::IndexedAccessType<'gc>,
    }
    impl<'gc> IndexedAccessType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::IndexedAccessType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::IndexedAccessType {
                    metadata: node.metadata.duplicate(),
                    object_type: node.object_type.duplicate(),
                    index_type: node.index_type.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::IndexedAccessType(self.inner))
        }
        /// Set the `object_type` field and mark the builder changed.
        pub fn object_type(&mut self, object_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.object_type = object_type; }
        /// Set the `index_type` field and mark the builder changed.
        pub fn index_type(&mut self, index_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.index_type = index_type; }
    }
    /// Clone-with-changes builder for [`super::OptionalIndexedAccessType`].
    #[derive(Debug)]
    pub struct OptionalIndexedAccessType<'gc> {
        is_changed: bool,
        pub(super) inner: super::OptionalIndexedAccessType<'gc>,
    }
    impl<'gc> OptionalIndexedAccessType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::OptionalIndexedAccessType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::OptionalIndexedAccessType {
                    metadata: node.metadata.duplicate(),
                    object_type: node.object_type.duplicate(),
                    index_type: node.index_type.duplicate(),
                    optional: Cell::new(node.optional.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::OptionalIndexedAccessType(self.inner))
        }
        /// Set the `object_type` field and mark the builder changed.
        pub fn object_type(&mut self, object_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.object_type = object_type; }
        /// Set the `index_type` field and mark the builder changed.
        pub fn index_type(&mut self, index_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.index_type = index_type; }
    }
    /// Clone-with-changes builder for [`super::ConditionalTypeAnnotation`].
    #[derive(Debug)]
    pub struct ConditionalTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::ConditionalTypeAnnotation<'gc>,
    }
    impl<'gc> ConditionalTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ConditionalTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ConditionalTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    check_type: node.check_type.duplicate(),
                    extends_type: node.extends_type.duplicate(),
                    true_type: node.true_type.duplicate(),
                    false_type: node.false_type.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ConditionalTypeAnnotation(self.inner))
        }
        /// Set the `check_type` field and mark the builder changed.
        pub fn check_type(&mut self, check_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.check_type = check_type; }
        /// Set the `extends_type` field and mark the builder changed.
        pub fn extends_type(&mut self, extends_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.extends_type = extends_type; }
        /// Set the `true_type` field and mark the builder changed.
        pub fn true_type(&mut self, true_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.true_type = true_type; }
        /// Set the `false_type` field and mark the builder changed.
        pub fn false_type(&mut self, false_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.false_type = false_type; }
    }
    /// Clone-with-changes builder for [`super::TypePredicate`].
    #[derive(Debug)]
    pub struct TypePredicate<'gc> {
        is_changed: bool,
        pub(super) inner: super::TypePredicate<'gc>,
    }
    impl<'gc> TypePredicate<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TypePredicate<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TypePredicate {
                    metadata: node.metadata.duplicate(),
                    parameter_name: node.parameter_name.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                    kind: Cell::new(node.kind.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TypePredicate(self.inner))
        }
        /// Set the `parameter_name` field and mark the builder changed.
        pub fn parameter_name(&mut self, parameter_name: &'gc Node<'gc>) { self.is_changed = true; self.inner.parameter_name = parameter_name; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::InterfaceTypeAnnotation`].
    #[derive(Debug)]
    pub struct InterfaceTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::InterfaceTypeAnnotation<'gc>,
    }
    impl<'gc> InterfaceTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::InterfaceTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::InterfaceTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    extends: node.extends.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::InterfaceTypeAnnotation(self.inner))
        }
        /// Set the `extends` field and mark the builder changed.
        pub fn extends(&mut self, extends: NodeList<'gc>) { self.is_changed = true; self.inner.extends = extends; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::TypeAlias`].
    #[derive(Debug)]
    pub struct TypeAlias<'gc> {
        is_changed: bool,
        pub(super) inner: super::TypeAlias<'gc>,
    }
    impl<'gc> TypeAlias<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TypeAlias<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TypeAlias {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    right: node.right.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TypeAlias(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: &'gc Node<'gc>) { self.is_changed = true; self.inner.right = right; }
    }
    /// Clone-with-changes builder for [`super::OpaqueType`].
    #[derive(Debug)]
    pub struct OpaqueType<'gc> {
        is_changed: bool,
        pub(super) inner: super::OpaqueType<'gc>,
    }
    impl<'gc> OpaqueType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::OpaqueType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::OpaqueType {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    impltype: node.impltype.duplicate(),
                    lower_bound: node.lower_bound.duplicate(),
                    upper_bound: node.upper_bound.duplicate(),
                    supertype: node.supertype.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::OpaqueType(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `impltype` field and mark the builder changed.
        pub fn impltype(&mut self, impltype: &'gc Node<'gc>) { self.is_changed = true; self.inner.impltype = impltype; }
        /// Set the `lower_bound` field and mark the builder changed.
        pub fn lower_bound(&mut self, lower_bound: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.lower_bound = lower_bound; }
        /// Set the `upper_bound` field and mark the builder changed.
        pub fn upper_bound(&mut self, upper_bound: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.upper_bound = upper_bound; }
        /// Set the `supertype` field and mark the builder changed.
        pub fn supertype(&mut self, supertype: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.supertype = supertype; }
    }
    /// Clone-with-changes builder for [`super::InterfaceDeclaration`].
    #[derive(Debug)]
    pub struct InterfaceDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::InterfaceDeclaration<'gc>,
    }
    impl<'gc> InterfaceDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::InterfaceDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::InterfaceDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    extends: node.extends.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::InterfaceDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `extends` field and mark the builder changed.
        pub fn extends(&mut self, extends: NodeList<'gc>) { self.is_changed = true; self.inner.extends = extends; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::DeclareTypeAlias`].
    #[derive(Debug)]
    pub struct DeclareTypeAlias<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareTypeAlias<'gc>,
    }
    impl<'gc> DeclareTypeAlias<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareTypeAlias<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareTypeAlias {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    right: node.right.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareTypeAlias(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: &'gc Node<'gc>) { self.is_changed = true; self.inner.right = right; }
    }
    /// Clone-with-changes builder for [`super::DeclareOpaqueType`].
    #[derive(Debug)]
    pub struct DeclareOpaqueType<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareOpaqueType<'gc>,
    }
    impl<'gc> DeclareOpaqueType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareOpaqueType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareOpaqueType {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    impltype: node.impltype.duplicate(),
                    lower_bound: node.lower_bound.duplicate(),
                    upper_bound: node.upper_bound.duplicate(),
                    supertype: node.supertype.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareOpaqueType(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `impltype` field and mark the builder changed.
        pub fn impltype(&mut self, impltype: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.impltype = impltype; }
        /// Set the `lower_bound` field and mark the builder changed.
        pub fn lower_bound(&mut self, lower_bound: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.lower_bound = lower_bound; }
        /// Set the `upper_bound` field and mark the builder changed.
        pub fn upper_bound(&mut self, upper_bound: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.upper_bound = upper_bound; }
        /// Set the `supertype` field and mark the builder changed.
        pub fn supertype(&mut self, supertype: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.supertype = supertype; }
    }
    /// Clone-with-changes builder for [`super::DeclareInterface`].
    #[derive(Debug)]
    pub struct DeclareInterface<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareInterface<'gc>,
    }
    impl<'gc> DeclareInterface<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareInterface<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareInterface {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    extends: node.extends.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareInterface(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `extends` field and mark the builder changed.
        pub fn extends(&mut self, extends: NodeList<'gc>) { self.is_changed = true; self.inner.extends = extends; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::DeclareClass`].
    #[derive(Debug)]
    pub struct DeclareClass<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareClass<'gc>,
    }
    impl<'gc> DeclareClass<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareClass<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareClass {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    extends: node.extends.duplicate(),
                    implements: node.implements.duplicate(),
                    mixins: node.mixins.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareClass(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `extends` field and mark the builder changed.
        pub fn extends(&mut self, extends: NodeList<'gc>) { self.is_changed = true; self.inner.extends = extends; }
        /// Set the `implements` field and mark the builder changed.
        pub fn implements(&mut self, implements: NodeList<'gc>) { self.is_changed = true; self.inner.implements = implements; }
        /// Set the `mixins` field and mark the builder changed.
        pub fn mixins(&mut self, mixins: NodeList<'gc>) { self.is_changed = true; self.inner.mixins = mixins; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::DeclareFunction`].
    #[derive(Debug)]
    pub struct DeclareFunction<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareFunction<'gc>,
    }
    impl<'gc> DeclareFunction<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareFunction<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareFunction {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    predicate: node.predicate.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareFunction(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `predicate` field and mark the builder changed.
        pub fn predicate(&mut self, predicate: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.predicate = predicate; }
    }
    /// Clone-with-changes builder for [`super::DeclareHook`].
    #[derive(Debug)]
    pub struct DeclareHook<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareHook<'gc>,
    }
    impl<'gc> DeclareHook<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareHook<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareHook {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareHook(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
    }
    /// Clone-with-changes builder for [`super::DeclareComponent`].
    #[derive(Debug)]
    pub struct DeclareComponent<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareComponent<'gc>,
    }
    impl<'gc> DeclareComponent<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareComponent<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareComponent {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    params: node.params.duplicate(),
                    rest: node.rest.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    renders_type: node.renders_type.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareComponent(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `rest` field and mark the builder changed.
        pub fn rest(&mut self, rest: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.rest = rest; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `renders_type` field and mark the builder changed.
        pub fn renders_type(&mut self, renders_type: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.renders_type = renders_type; }
    }
    /// Clone-with-changes builder for [`super::DeclareVariable`].
    #[derive(Debug)]
    pub struct DeclareVariable<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareVariable<'gc>,
    }
    impl<'gc> DeclareVariable<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareVariable<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareVariable {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    kind: Cell::new(node.kind.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareVariable(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
    }
    /// Clone-with-changes builder for [`super::DeclareEnum`].
    #[derive(Debug)]
    pub struct DeclareEnum<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareEnum<'gc>,
    }
    impl<'gc> DeclareEnum<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareEnum<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareEnum {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareEnum(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::DeclareExportDeclaration`].
    #[derive(Debug)]
    pub struct DeclareExportDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareExportDeclaration<'gc>,
    }
    impl<'gc> DeclareExportDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareExportDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareExportDeclaration {
                    metadata: node.metadata.duplicate(),
                    declaration: node.declaration.duplicate(),
                    specifiers: node.specifiers.duplicate(),
                    source: node.source.duplicate(),
                    default: Cell::new(node.default.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareExportDeclaration(self.inner))
        }
        /// Set the `declaration` field and mark the builder changed.
        pub fn declaration(&mut self, declaration: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.declaration = declaration; }
        /// Set the `specifiers` field and mark the builder changed.
        pub fn specifiers(&mut self, specifiers: NodeList<'gc>) { self.is_changed = true; self.inner.specifiers = specifiers; }
        /// Set the `source` field and mark the builder changed.
        pub fn source(&mut self, source: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.source = source; }
    }
    /// Clone-with-changes builder for [`super::DeclareExportAllDeclaration`].
    #[derive(Debug)]
    pub struct DeclareExportAllDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareExportAllDeclaration<'gc>,
    }
    impl<'gc> DeclareExportAllDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareExportAllDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareExportAllDeclaration {
                    metadata: node.metadata.duplicate(),
                    source: node.source.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareExportAllDeclaration(self.inner))
        }
        /// Set the `source` field and mark the builder changed.
        pub fn source(&mut self, source: &'gc Node<'gc>) { self.is_changed = true; self.inner.source = source; }
    }
    /// Clone-with-changes builder for [`super::DeclareModule`].
    #[derive(Debug)]
    pub struct DeclareModule<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareModule<'gc>,
    }
    impl<'gc> DeclareModule<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareModule<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareModule {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareModule(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::DeclareNamespace`].
    #[derive(Debug)]
    pub struct DeclareNamespace<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareNamespace<'gc>,
    }
    impl<'gc> DeclareNamespace<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareNamespace<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareNamespace {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareNamespace(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::DeclareModuleExports`].
    #[derive(Debug)]
    pub struct DeclareModuleExports<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclareModuleExports<'gc>,
    }
    impl<'gc> DeclareModuleExports<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclareModuleExports<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclareModuleExports {
                    metadata: node.metadata.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclareModuleExports(self.inner))
        }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::InterfaceExtends`].
    #[derive(Debug)]
    pub struct InterfaceExtends<'gc> {
        is_changed: bool,
        pub(super) inner: super::InterfaceExtends<'gc>,
    }
    impl<'gc> InterfaceExtends<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::InterfaceExtends<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::InterfaceExtends {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::InterfaceExtends(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::ClassImplements`].
    #[derive(Debug)]
    pub struct ClassImplements<'gc> {
        is_changed: bool,
        pub(super) inner: super::ClassImplements<'gc>,
    }
    impl<'gc> ClassImplements<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ClassImplements<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ClassImplements {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ClassImplements(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::TypeAnnotation`].
    #[derive(Debug)]
    pub struct TypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::TypeAnnotation<'gc>,
    }
    impl<'gc> TypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TypeAnnotation(self.inner))
        }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::ObjectTypeAnnotation`].
    #[derive(Debug)]
    pub struct ObjectTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::ObjectTypeAnnotation<'gc>,
    }
    impl<'gc> ObjectTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ObjectTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ObjectTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    properties: node.properties.duplicate(),
                    indexers: node.indexers.duplicate(),
                    call_properties: node.call_properties.duplicate(),
                    internal_slots: node.internal_slots.duplicate(),
                    inexact: Cell::new(node.inexact.get()),
                    exact: Cell::new(node.exact.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ObjectTypeAnnotation(self.inner))
        }
        /// Set the `properties` field and mark the builder changed.
        pub fn properties(&mut self, properties: NodeList<'gc>) { self.is_changed = true; self.inner.properties = properties; }
        /// Set the `indexers` field and mark the builder changed.
        pub fn indexers(&mut self, indexers: NodeList<'gc>) { self.is_changed = true; self.inner.indexers = indexers; }
        /// Set the `call_properties` field and mark the builder changed.
        pub fn call_properties(&mut self, call_properties: NodeList<'gc>) { self.is_changed = true; self.inner.call_properties = call_properties; }
        /// Set the `internal_slots` field and mark the builder changed.
        pub fn internal_slots(&mut self, internal_slots: NodeList<'gc>) { self.is_changed = true; self.inner.internal_slots = internal_slots; }
    }
    /// Clone-with-changes builder for [`super::ObjectTypeProperty`].
    #[derive(Debug)]
    pub struct ObjectTypeProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::ObjectTypeProperty<'gc>,
    }
    impl<'gc> ObjectTypeProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ObjectTypeProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ObjectTypeProperty {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    value: node.value.duplicate(),
                    method: Cell::new(node.method.get()),
                    optional: Cell::new(node.optional.get()),
                    r#static: Cell::new(node.r#static.get()),
                    proto: Cell::new(node.proto.get()),
                    variance: node.variance.duplicate(),
                    kind: Cell::new(node.kind.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ObjectTypeProperty(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
        /// Set the `variance` field and mark the builder changed.
        pub fn variance(&mut self, variance: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.variance = variance; }
    }
    /// Clone-with-changes builder for [`super::ObjectTypeSpreadProperty`].
    #[derive(Debug)]
    pub struct ObjectTypeSpreadProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::ObjectTypeSpreadProperty<'gc>,
    }
    impl<'gc> ObjectTypeSpreadProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ObjectTypeSpreadProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ObjectTypeSpreadProperty {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ObjectTypeSpreadProperty(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
    /// Clone-with-changes builder for [`super::ObjectTypeInternalSlot`].
    #[derive(Debug)]
    pub struct ObjectTypeInternalSlot<'gc> {
        is_changed: bool,
        pub(super) inner: super::ObjectTypeInternalSlot<'gc>,
    }
    impl<'gc> ObjectTypeInternalSlot<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ObjectTypeInternalSlot<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ObjectTypeInternalSlot {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    value: node.value.duplicate(),
                    optional: Cell::new(node.optional.get()),
                    r#static: Cell::new(node.r#static.get()),
                    method: Cell::new(node.method.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ObjectTypeInternalSlot(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
    }
    /// Clone-with-changes builder for [`super::ObjectTypeCallProperty`].
    #[derive(Debug)]
    pub struct ObjectTypeCallProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::ObjectTypeCallProperty<'gc>,
    }
    impl<'gc> ObjectTypeCallProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ObjectTypeCallProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ObjectTypeCallProperty {
                    metadata: node.metadata.duplicate(),
                    value: node.value.duplicate(),
                    r#static: Cell::new(node.r#static.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ObjectTypeCallProperty(self.inner))
        }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
    }
    /// Clone-with-changes builder for [`super::ObjectTypeIndexer`].
    #[derive(Debug)]
    pub struct ObjectTypeIndexer<'gc> {
        is_changed: bool,
        pub(super) inner: super::ObjectTypeIndexer<'gc>,
    }
    impl<'gc> ObjectTypeIndexer<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ObjectTypeIndexer<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ObjectTypeIndexer {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    key: node.key.duplicate(),
                    value: node.value.duplicate(),
                    r#static: Cell::new(node.r#static.get()),
                    variance: node.variance.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ObjectTypeIndexer(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
        /// Set the `variance` field and mark the builder changed.
        pub fn variance(&mut self, variance: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.variance = variance; }
    }
    /// Clone-with-changes builder for [`super::ObjectTypeMappedTypeProperty`].
    #[derive(Debug)]
    pub struct ObjectTypeMappedTypeProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::ObjectTypeMappedTypeProperty<'gc>,
    }
    impl<'gc> ObjectTypeMappedTypeProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ObjectTypeMappedTypeProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ObjectTypeMappedTypeProperty {
                    metadata: node.metadata.duplicate(),
                    key_tparam: node.key_tparam.duplicate(),
                    prop_type: node.prop_type.duplicate(),
                    source_type: node.source_type.duplicate(),
                    variance: node.variance.duplicate(),
                    optional: Cell::new(node.optional.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ObjectTypeMappedTypeProperty(self.inner))
        }
        /// Set the `key_tparam` field and mark the builder changed.
        pub fn key_tparam(&mut self, key_tparam: &'gc Node<'gc>) { self.is_changed = true; self.inner.key_tparam = key_tparam; }
        /// Set the `prop_type` field and mark the builder changed.
        pub fn prop_type(&mut self, prop_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.prop_type = prop_type; }
        /// Set the `source_type` field and mark the builder changed.
        pub fn source_type(&mut self, source_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.source_type = source_type; }
        /// Set the `variance` field and mark the builder changed.
        pub fn variance(&mut self, variance: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.variance = variance; }
    }
    /// Clone-with-changes builder for [`super::Variance`].
    #[derive(Debug)]
    pub struct Variance<'gc> {
        is_changed: bool,
        pub(super) inner: super::Variance<'gc>,
    }
    impl<'gc> Variance<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::Variance<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::Variance {
                    metadata: node.metadata.duplicate(),
                    kind: Cell::new(node.kind.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::Variance(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TypeParameterDeclaration`].
    #[derive(Debug)]
    pub struct TypeParameterDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::TypeParameterDeclaration<'gc>,
    }
    impl<'gc> TypeParameterDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TypeParameterDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TypeParameterDeclaration {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TypeParameterDeclaration(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
    }
    /// Clone-with-changes builder for [`super::TypeParameter`].
    #[derive(Debug)]
    pub struct TypeParameter<'gc> {
        is_changed: bool,
        pub(super) inner: super::TypeParameter<'gc>,
    }
    impl<'gc> TypeParameter<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TypeParameter<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TypeParameter {
                    metadata: node.metadata.duplicate(),
                    name: Cell::new(node.name.get()),
                    r#const: Cell::new(node.r#const.get()),
                    bound: node.bound.duplicate(),
                    variance: node.variance.duplicate(),
                    default: node.default.duplicate(),
                    uses_extends_bound: Cell::new(node.uses_extends_bound.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TypeParameter(self.inner))
        }
        /// Set the `bound` field and mark the builder changed.
        pub fn bound(&mut self, bound: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.bound = bound; }
        /// Set the `variance` field and mark the builder changed.
        pub fn variance(&mut self, variance: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.variance = variance; }
        /// Set the `default` field and mark the builder changed.
        pub fn default(&mut self, default: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.default = default; }
    }
    /// Clone-with-changes builder for [`super::TypeParameterInstantiation`].
    #[derive(Debug)]
    pub struct TypeParameterInstantiation<'gc> {
        is_changed: bool,
        pub(super) inner: super::TypeParameterInstantiation<'gc>,
    }
    impl<'gc> TypeParameterInstantiation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TypeParameterInstantiation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TypeParameterInstantiation {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TypeParameterInstantiation(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
    }
    /// Clone-with-changes builder for [`super::TypeCastExpression`].
    #[derive(Debug)]
    pub struct TypeCastExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::TypeCastExpression<'gc>,
    }
    impl<'gc> TypeCastExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TypeCastExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TypeCastExpression {
                    metadata: node.metadata.duplicate(),
                    expression: node.expression.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TypeCastExpression(self.inner))
        }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::AsExpression`].
    #[derive(Debug)]
    pub struct AsExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::AsExpression<'gc>,
    }
    impl<'gc> AsExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::AsExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::AsExpression {
                    metadata: node.metadata.duplicate(),
                    expression: node.expression.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::AsExpression(self.inner))
        }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::AsConstExpression`].
    #[derive(Debug)]
    pub struct AsConstExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::AsConstExpression<'gc>,
    }
    impl<'gc> AsConstExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::AsConstExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::AsConstExpression {
                    metadata: node.metadata.duplicate(),
                    expression: node.expression.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::AsConstExpression(self.inner))
        }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
    }
    /// Clone-with-changes builder for [`super::InferredPredicate`].
    #[derive(Debug)]
    pub struct InferredPredicate<'gc> {
        is_changed: bool,
        pub(super) inner: super::InferredPredicate<'gc>,
    }
    impl<'gc> InferredPredicate<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::InferredPredicate<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::InferredPredicate {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::InferredPredicate(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::DeclaredPredicate`].
    #[derive(Debug)]
    pub struct DeclaredPredicate<'gc> {
        is_changed: bool,
        pub(super) inner: super::DeclaredPredicate<'gc>,
    }
    impl<'gc> DeclaredPredicate<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::DeclaredPredicate<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::DeclaredPredicate {
                    metadata: node.metadata.duplicate(),
                    value: node.value.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::DeclaredPredicate(self.inner))
        }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
    }
    /// Clone-with-changes builder for [`super::EnumDeclaration`].
    #[derive(Debug)]
    pub struct EnumDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumDeclaration<'gc>,
    }
    impl<'gc> EnumDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::EnumStringBody`].
    #[derive(Debug)]
    pub struct EnumStringBody<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumStringBody<'gc>,
    }
    impl<'gc> EnumStringBody<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumStringBody<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumStringBody {
                    metadata: node.metadata.duplicate(),
                    members: node.members.duplicate(),
                    explicit_type: Cell::new(node.explicit_type.get()),
                    has_unknown_members: Cell::new(node.has_unknown_members.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumStringBody(self.inner))
        }
        /// Set the `members` field and mark the builder changed.
        pub fn members(&mut self, members: NodeList<'gc>) { self.is_changed = true; self.inner.members = members; }
    }
    /// Clone-with-changes builder for [`super::EnumNumberBody`].
    #[derive(Debug)]
    pub struct EnumNumberBody<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumNumberBody<'gc>,
    }
    impl<'gc> EnumNumberBody<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumNumberBody<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumNumberBody {
                    metadata: node.metadata.duplicate(),
                    members: node.members.duplicate(),
                    explicit_type: Cell::new(node.explicit_type.get()),
                    has_unknown_members: Cell::new(node.has_unknown_members.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumNumberBody(self.inner))
        }
        /// Set the `members` field and mark the builder changed.
        pub fn members(&mut self, members: NodeList<'gc>) { self.is_changed = true; self.inner.members = members; }
    }
    /// Clone-with-changes builder for [`super::EnumBigIntBody`].
    #[derive(Debug)]
    pub struct EnumBigIntBody<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumBigIntBody<'gc>,
    }
    impl<'gc> EnumBigIntBody<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumBigIntBody<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumBigIntBody {
                    metadata: node.metadata.duplicate(),
                    members: node.members.duplicate(),
                    explicit_type: Cell::new(node.explicit_type.get()),
                    has_unknown_members: Cell::new(node.has_unknown_members.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumBigIntBody(self.inner))
        }
        /// Set the `members` field and mark the builder changed.
        pub fn members(&mut self, members: NodeList<'gc>) { self.is_changed = true; self.inner.members = members; }
    }
    /// Clone-with-changes builder for [`super::EnumBooleanBody`].
    #[derive(Debug)]
    pub struct EnumBooleanBody<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumBooleanBody<'gc>,
    }
    impl<'gc> EnumBooleanBody<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumBooleanBody<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumBooleanBody {
                    metadata: node.metadata.duplicate(),
                    members: node.members.duplicate(),
                    explicit_type: Cell::new(node.explicit_type.get()),
                    has_unknown_members: Cell::new(node.has_unknown_members.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumBooleanBody(self.inner))
        }
        /// Set the `members` field and mark the builder changed.
        pub fn members(&mut self, members: NodeList<'gc>) { self.is_changed = true; self.inner.members = members; }
    }
    /// Clone-with-changes builder for [`super::EnumSymbolBody`].
    #[derive(Debug)]
    pub struct EnumSymbolBody<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumSymbolBody<'gc>,
    }
    impl<'gc> EnumSymbolBody<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumSymbolBody<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumSymbolBody {
                    metadata: node.metadata.duplicate(),
                    members: node.members.duplicate(),
                    has_unknown_members: Cell::new(node.has_unknown_members.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumSymbolBody(self.inner))
        }
        /// Set the `members` field and mark the builder changed.
        pub fn members(&mut self, members: NodeList<'gc>) { self.is_changed = true; self.inner.members = members; }
    }
    /// Clone-with-changes builder for [`super::EnumDefaultedMember`].
    #[derive(Debug)]
    pub struct EnumDefaultedMember<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumDefaultedMember<'gc>,
    }
    impl<'gc> EnumDefaultedMember<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumDefaultedMember<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumDefaultedMember {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumDefaultedMember(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
    }
    /// Clone-with-changes builder for [`super::EnumStringMember`].
    #[derive(Debug)]
    pub struct EnumStringMember<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumStringMember<'gc>,
    }
    impl<'gc> EnumStringMember<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumStringMember<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumStringMember {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    init: node.init.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumStringMember(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `init` field and mark the builder changed.
        pub fn init(&mut self, init: &'gc Node<'gc>) { self.is_changed = true; self.inner.init = init; }
    }
    /// Clone-with-changes builder for [`super::EnumNumberMember`].
    #[derive(Debug)]
    pub struct EnumNumberMember<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumNumberMember<'gc>,
    }
    impl<'gc> EnumNumberMember<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumNumberMember<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumNumberMember {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    init: node.init.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumNumberMember(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `init` field and mark the builder changed.
        pub fn init(&mut self, init: &'gc Node<'gc>) { self.is_changed = true; self.inner.init = init; }
    }
    /// Clone-with-changes builder for [`super::EnumBigIntMember`].
    #[derive(Debug)]
    pub struct EnumBigIntMember<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumBigIntMember<'gc>,
    }
    impl<'gc> EnumBigIntMember<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumBigIntMember<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumBigIntMember {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    init: node.init.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumBigIntMember(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `init` field and mark the builder changed.
        pub fn init(&mut self, init: &'gc Node<'gc>) { self.is_changed = true; self.inner.init = init; }
    }
    /// Clone-with-changes builder for [`super::EnumBooleanMember`].
    #[derive(Debug)]
    pub struct EnumBooleanMember<'gc> {
        is_changed: bool,
        pub(super) inner: super::EnumBooleanMember<'gc>,
    }
    impl<'gc> EnumBooleanMember<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::EnumBooleanMember<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::EnumBooleanMember {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    init: node.init.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::EnumBooleanMember(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `init` field and mark the builder changed.
        pub fn init(&mut self, init: &'gc Node<'gc>) { self.is_changed = true; self.inner.init = init; }
    }
    /// Clone-with-changes builder for [`super::ComponentParameter`].
    #[derive(Debug)]
    pub struct ComponentParameter<'gc> {
        is_changed: bool,
        pub(super) inner: super::ComponentParameter<'gc>,
    }
    impl<'gc> ComponentParameter<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ComponentParameter<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ComponentParameter {
                    metadata: node.metadata.duplicate(),
                    name: node.name.duplicate(),
                    local: node.local.duplicate(),
                    shorthand: Cell::new(node.shorthand.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ComponentParameter(self.inner))
        }
        /// Set the `name` field and mark the builder changed.
        pub fn name(&mut self, name: &'gc Node<'gc>) { self.is_changed = true; self.inner.name = name; }
        /// Set the `local` field and mark the builder changed.
        pub fn local(&mut self, local: &'gc Node<'gc>) { self.is_changed = true; self.inner.local = local; }
    }
    /// Clone-with-changes builder for [`super::RecordDeclaration`].
    #[derive(Debug)]
    pub struct RecordDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::RecordDeclaration<'gc>,
    }
    impl<'gc> RecordDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::RecordDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::RecordDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    implements: node.implements.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::RecordDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `implements` field and mark the builder changed.
        pub fn implements(&mut self, implements: NodeList<'gc>) { self.is_changed = true; self.inner.implements = implements; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::RecordDeclarationImplements`].
    #[derive(Debug)]
    pub struct RecordDeclarationImplements<'gc> {
        is_changed: bool,
        pub(super) inner: super::RecordDeclarationImplements<'gc>,
    }
    impl<'gc> RecordDeclarationImplements<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::RecordDeclarationImplements<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::RecordDeclarationImplements {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_arguments: node.type_arguments.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::RecordDeclarationImplements(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_arguments` field and mark the builder changed.
        pub fn type_arguments(&mut self, type_arguments: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_arguments = type_arguments; }
    }
    /// Clone-with-changes builder for [`super::RecordDeclarationBody`].
    #[derive(Debug)]
    pub struct RecordDeclarationBody<'gc> {
        is_changed: bool,
        pub(super) inner: super::RecordDeclarationBody<'gc>,
    }
    impl<'gc> RecordDeclarationBody<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::RecordDeclarationBody<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::RecordDeclarationBody {
                    metadata: node.metadata.duplicate(),
                    elements: node.elements.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::RecordDeclarationBody(self.inner))
        }
        /// Set the `elements` field and mark the builder changed.
        pub fn elements(&mut self, elements: NodeList<'gc>) { self.is_changed = true; self.inner.elements = elements; }
    }
    /// Clone-with-changes builder for [`super::RecordDeclarationProperty`].
    #[derive(Debug)]
    pub struct RecordDeclarationProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::RecordDeclarationProperty<'gc>,
    }
    impl<'gc> RecordDeclarationProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::RecordDeclarationProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::RecordDeclarationProperty {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                    default_value: node.default_value.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::RecordDeclarationProperty(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
        /// Set the `default_value` field and mark the builder changed.
        pub fn default_value(&mut self, default_value: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.default_value = default_value; }
    }
    /// Clone-with-changes builder for
    /// [`super::RecordDeclarationStaticProperty`].
    #[derive(Debug)]
    pub struct RecordDeclarationStaticProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::RecordDeclarationStaticProperty<'gc>,
    }
    impl<'gc> RecordDeclarationStaticProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::RecordDeclarationStaticProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::RecordDeclarationStaticProperty {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                    value: node.value.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::RecordDeclarationStaticProperty(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
        /// Set the `value` field and mark the builder changed.
        pub fn value(&mut self, value: &'gc Node<'gc>) { self.is_changed = true; self.inner.value = value; }
    }
    /// Clone-with-changes builder for [`super::RecordExpression`].
    #[derive(Debug)]
    pub struct RecordExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::RecordExpression<'gc>,
    }
    impl<'gc> RecordExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::RecordExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::RecordExpression {
                    metadata: node.metadata.duplicate(),
                    record_constructor: node.record_constructor.duplicate(),
                    type_arguments: node.type_arguments.duplicate(),
                    properties: node.properties.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::RecordExpression(self.inner))
        }
        /// Set the `record_constructor` field and mark the builder changed.
        pub fn record_constructor(&mut self, record_constructor: &'gc Node<'gc>) { self.is_changed = true; self.inner.record_constructor = record_constructor; }
        /// Set the `type_arguments` field and mark the builder changed.
        pub fn type_arguments(&mut self, type_arguments: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_arguments = type_arguments; }
        /// Set the `properties` field and mark the builder changed.
        pub fn properties(&mut self, properties: &'gc Node<'gc>) { self.is_changed = true; self.inner.properties = properties; }
    }
    /// Clone-with-changes builder for [`super::RecordExpressionProperties`].
    #[derive(Debug)]
    pub struct RecordExpressionProperties<'gc> {
        is_changed: bool,
        pub(super) inner: super::RecordExpressionProperties<'gc>,
    }
    impl<'gc> RecordExpressionProperties<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::RecordExpressionProperties<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::RecordExpressionProperties {
                    metadata: node.metadata.duplicate(),
                    properties: node.properties.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::RecordExpressionProperties(self.inner))
        }
        /// Set the `properties` field and mark the builder changed.
        pub fn properties(&mut self, properties: NodeList<'gc>) { self.is_changed = true; self.inner.properties = properties; }
    }
    /// Clone-with-changes builder for [`super::TSTypeAnnotation`].
    #[derive(Debug)]
    pub struct TSTypeAnnotation<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypeAnnotation<'gc>,
    }
    impl<'gc> TSTypeAnnotation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypeAnnotation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypeAnnotation {
                    metadata: node.metadata.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypeAnnotation(self.inner))
        }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::TSAnyKeyword`].
    #[derive(Debug)]
    pub struct TSAnyKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSAnyKeyword<'gc>,
    }
    impl<'gc> TSAnyKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSAnyKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSAnyKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSAnyKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSNumberKeyword`].
    #[derive(Debug)]
    pub struct TSNumberKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSNumberKeyword<'gc>,
    }
    impl<'gc> TSNumberKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSNumberKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSNumberKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSNumberKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSBooleanKeyword`].
    #[derive(Debug)]
    pub struct TSBooleanKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSBooleanKeyword<'gc>,
    }
    impl<'gc> TSBooleanKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSBooleanKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSBooleanKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSBooleanKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSStringKeyword`].
    #[derive(Debug)]
    pub struct TSStringKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSStringKeyword<'gc>,
    }
    impl<'gc> TSStringKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSStringKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSStringKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSStringKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSSymbolKeyword`].
    #[derive(Debug)]
    pub struct TSSymbolKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSSymbolKeyword<'gc>,
    }
    impl<'gc> TSSymbolKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSSymbolKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSSymbolKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSSymbolKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSVoidKeyword`].
    #[derive(Debug)]
    pub struct TSVoidKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSVoidKeyword<'gc>,
    }
    impl<'gc> TSVoidKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSVoidKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSVoidKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSVoidKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSUndefinedKeyword`].
    #[derive(Debug)]
    pub struct TSUndefinedKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSUndefinedKeyword<'gc>,
    }
    impl<'gc> TSUndefinedKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSUndefinedKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSUndefinedKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSUndefinedKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSUnknownKeyword`].
    #[derive(Debug)]
    pub struct TSUnknownKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSUnknownKeyword<'gc>,
    }
    impl<'gc> TSUnknownKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSUnknownKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSUnknownKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSUnknownKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSNeverKeyword`].
    #[derive(Debug)]
    pub struct TSNeverKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSNeverKeyword<'gc>,
    }
    impl<'gc> TSNeverKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSNeverKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSNeverKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSNeverKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSBigIntKeyword`].
    #[derive(Debug)]
    pub struct TSBigIntKeyword<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSBigIntKeyword<'gc>,
    }
    impl<'gc> TSBigIntKeyword<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSBigIntKeyword<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSBigIntKeyword {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSBigIntKeyword(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSThisType`].
    #[derive(Debug)]
    pub struct TSThisType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSThisType<'gc>,
    }
    impl<'gc> TSThisType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSThisType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSThisType {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSThisType(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::TSLiteralType`].
    #[derive(Debug)]
    pub struct TSLiteralType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSLiteralType<'gc>,
    }
    impl<'gc> TSLiteralType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSLiteralType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSLiteralType {
                    metadata: node.metadata.duplicate(),
                    literal: node.literal.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSLiteralType(self.inner))
        }
        /// Set the `literal` field and mark the builder changed.
        pub fn literal(&mut self, literal: &'gc Node<'gc>) { self.is_changed = true; self.inner.literal = literal; }
    }
    /// Clone-with-changes builder for [`super::TSIndexedAccessType`].
    #[derive(Debug)]
    pub struct TSIndexedAccessType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSIndexedAccessType<'gc>,
    }
    impl<'gc> TSIndexedAccessType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSIndexedAccessType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSIndexedAccessType {
                    metadata: node.metadata.duplicate(),
                    object_type: node.object_type.duplicate(),
                    index_type: node.index_type.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSIndexedAccessType(self.inner))
        }
        /// Set the `object_type` field and mark the builder changed.
        pub fn object_type(&mut self, object_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.object_type = object_type; }
        /// Set the `index_type` field and mark the builder changed.
        pub fn index_type(&mut self, index_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.index_type = index_type; }
    }
    /// Clone-with-changes builder for [`super::TSArrayType`].
    #[derive(Debug)]
    pub struct TSArrayType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSArrayType<'gc>,
    }
    impl<'gc> TSArrayType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSArrayType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSArrayType {
                    metadata: node.metadata.duplicate(),
                    element_type: node.element_type.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSArrayType(self.inner))
        }
        /// Set the `element_type` field and mark the builder changed.
        pub fn element_type(&mut self, element_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.element_type = element_type; }
    }
    /// Clone-with-changes builder for [`super::TSTypeReference`].
    #[derive(Debug)]
    pub struct TSTypeReference<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypeReference<'gc>,
    }
    impl<'gc> TSTypeReference<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypeReference<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypeReference {
                    metadata: node.metadata.duplicate(),
                    type_name: node.type_name.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypeReference(self.inner))
        }
        /// Set the `type_name` field and mark the builder changed.
        pub fn type_name(&mut self, type_name: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_name = type_name; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::TSQualifiedName`].
    #[derive(Debug)]
    pub struct TSQualifiedName<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSQualifiedName<'gc>,
    }
    impl<'gc> TSQualifiedName<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSQualifiedName<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSQualifiedName {
                    metadata: node.metadata.duplicate(),
                    left: node.left.duplicate(),
                    right: node.right.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSQualifiedName(self.inner))
        }
        /// Set the `left` field and mark the builder changed.
        pub fn left(&mut self, left: &'gc Node<'gc>) { self.is_changed = true; self.inner.left = left; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.right = right; }
    }
    /// Clone-with-changes builder for [`super::TSFunctionType`].
    #[derive(Debug)]
    pub struct TSFunctionType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSFunctionType<'gc>,
    }
    impl<'gc> TSFunctionType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSFunctionType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSFunctionType {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                    return_type: node.return_type.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSFunctionType(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.return_type = return_type; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::TSConstructorType`].
    #[derive(Debug)]
    pub struct TSConstructorType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSConstructorType<'gc>,
    }
    impl<'gc> TSConstructorType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSConstructorType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSConstructorType {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                    return_type: node.return_type.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSConstructorType(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.return_type = return_type; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::TSTypePredicate`].
    #[derive(Debug)]
    pub struct TSTypePredicate<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypePredicate<'gc>,
    }
    impl<'gc> TSTypePredicate<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypePredicate<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypePredicate {
                    metadata: node.metadata.duplicate(),
                    parameter_name: node.parameter_name.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypePredicate(self.inner))
        }
        /// Set the `parameter_name` field and mark the builder changed.
        pub fn parameter_name(&mut self, parameter_name: &'gc Node<'gc>) { self.is_changed = true; self.inner.parameter_name = parameter_name; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::TSTupleType`].
    #[derive(Debug)]
    pub struct TSTupleType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTupleType<'gc>,
    }
    impl<'gc> TSTupleType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTupleType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTupleType {
                    metadata: node.metadata.duplicate(),
                    element_types: node.element_types.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTupleType(self.inner))
        }
        /// Set the `element_types` field and mark the builder changed.
        pub fn element_types(&mut self, element_types: NodeList<'gc>) { self.is_changed = true; self.inner.element_types = element_types; }
    }
    /// Clone-with-changes builder for [`super::TSTypeAssertion`].
    #[derive(Debug)]
    pub struct TSTypeAssertion<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypeAssertion<'gc>,
    }
    impl<'gc> TSTypeAssertion<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypeAssertion<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypeAssertion {
                    metadata: node.metadata.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                    expression: node.expression.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypeAssertion(self.inner))
        }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
    }
    /// Clone-with-changes builder for [`super::TSAsExpression`].
    #[derive(Debug)]
    pub struct TSAsExpression<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSAsExpression<'gc>,
    }
    impl<'gc> TSAsExpression<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSAsExpression<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSAsExpression {
                    metadata: node.metadata.duplicate(),
                    expression: node.expression.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSAsExpression(self.inner))
        }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::TSParameterProperty`].
    #[derive(Debug)]
    pub struct TSParameterProperty<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSParameterProperty<'gc>,
    }
    impl<'gc> TSParameterProperty<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSParameterProperty<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSParameterProperty {
                    metadata: node.metadata.duplicate(),
                    parameter: node.parameter.duplicate(),
                    accessibility: Cell::new(node.accessibility.get()),
                    readonly: Cell::new(node.readonly.get()),
                    r#static: Cell::new(node.r#static.get()),
                    export: Cell::new(node.export.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSParameterProperty(self.inner))
        }
        /// Set the `parameter` field and mark the builder changed.
        pub fn parameter(&mut self, parameter: &'gc Node<'gc>) { self.is_changed = true; self.inner.parameter = parameter; }
    }
    /// Clone-with-changes builder for [`super::TSTypeAliasDeclaration`].
    #[derive(Debug)]
    pub struct TSTypeAliasDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypeAliasDeclaration<'gc>,
    }
    impl<'gc> TSTypeAliasDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypeAliasDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypeAliasDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypeAliasDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: &'gc Node<'gc>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::TSInterfaceDeclaration`].
    #[derive(Debug)]
    pub struct TSInterfaceDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSInterfaceDeclaration<'gc>,
    }
    impl<'gc> TSInterfaceDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSInterfaceDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSInterfaceDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    body: node.body.duplicate(),
                    extends: node.extends.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSInterfaceDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
        /// Set the `extends` field and mark the builder changed.
        pub fn extends(&mut self, extends: NodeList<'gc>) { self.is_changed = true; self.inner.extends = extends; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::TSInterfaceHeritage`].
    #[derive(Debug)]
    pub struct TSInterfaceHeritage<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSInterfaceHeritage<'gc>,
    }
    impl<'gc> TSInterfaceHeritage<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSInterfaceHeritage<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSInterfaceHeritage {
                    metadata: node.metadata.duplicate(),
                    expression: node.expression.duplicate(),
                    type_parameters: node.type_parameters.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSInterfaceHeritage(self.inner))
        }
        /// Set the `expression` field and mark the builder changed.
        pub fn expression(&mut self, expression: &'gc Node<'gc>) { self.is_changed = true; self.inner.expression = expression; }
        /// Set the `type_parameters` field and mark the builder changed.
        pub fn type_parameters(&mut self, type_parameters: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_parameters = type_parameters; }
    }
    /// Clone-with-changes builder for [`super::TSInterfaceBody`].
    #[derive(Debug)]
    pub struct TSInterfaceBody<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSInterfaceBody<'gc>,
    }
    impl<'gc> TSInterfaceBody<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSInterfaceBody<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSInterfaceBody {
                    metadata: node.metadata.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSInterfaceBody(self.inner))
        }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: NodeList<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::TSEnumDeclaration`].
    #[derive(Debug)]
    pub struct TSEnumDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSEnumDeclaration<'gc>,
    }
    impl<'gc> TSEnumDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSEnumDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSEnumDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    members: node.members.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSEnumDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `members` field and mark the builder changed.
        pub fn members(&mut self, members: NodeList<'gc>) { self.is_changed = true; self.inner.members = members; }
    }
    /// Clone-with-changes builder for [`super::TSEnumMember`].
    #[derive(Debug)]
    pub struct TSEnumMember<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSEnumMember<'gc>,
    }
    impl<'gc> TSEnumMember<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSEnumMember<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSEnumMember {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    initializer: node.initializer.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSEnumMember(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `initializer` field and mark the builder changed.
        pub fn initializer(&mut self, initializer: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.initializer = initializer; }
    }
    /// Clone-with-changes builder for [`super::TSModuleDeclaration`].
    #[derive(Debug)]
    pub struct TSModuleDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSModuleDeclaration<'gc>,
    }
    impl<'gc> TSModuleDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSModuleDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSModuleDeclaration {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSModuleDeclaration(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: &'gc Node<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::TSModuleBlock`].
    #[derive(Debug)]
    pub struct TSModuleBlock<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSModuleBlock<'gc>,
    }
    impl<'gc> TSModuleBlock<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSModuleBlock<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSModuleBlock {
                    metadata: node.metadata.duplicate(),
                    body: node.body.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSModuleBlock(self.inner))
        }
        /// Set the `body` field and mark the builder changed.
        pub fn body(&mut self, body: NodeList<'gc>) { self.is_changed = true; self.inner.body = body; }
    }
    /// Clone-with-changes builder for [`super::TSModuleMember`].
    #[derive(Debug)]
    pub struct TSModuleMember<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSModuleMember<'gc>,
    }
    impl<'gc> TSModuleMember<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSModuleMember<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSModuleMember {
                    metadata: node.metadata.duplicate(),
                    id: node.id.duplicate(),
                    initializer: node.initializer.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSModuleMember(self.inner))
        }
        /// Set the `id` field and mark the builder changed.
        pub fn id(&mut self, id: &'gc Node<'gc>) { self.is_changed = true; self.inner.id = id; }
        /// Set the `initializer` field and mark the builder changed.
        pub fn initializer(&mut self, initializer: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.initializer = initializer; }
    }
    /// Clone-with-changes builder for [`super::TSTypeParameterDeclaration`].
    #[derive(Debug)]
    pub struct TSTypeParameterDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypeParameterDeclaration<'gc>,
    }
    impl<'gc> TSTypeParameterDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypeParameterDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypeParameterDeclaration {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypeParameterDeclaration(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
    }
    /// Clone-with-changes builder for [`super::TSTypeParameter`].
    #[derive(Debug)]
    pub struct TSTypeParameter<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypeParameter<'gc>,
    }
    impl<'gc> TSTypeParameter<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypeParameter<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypeParameter {
                    metadata: node.metadata.duplicate(),
                    name: node.name.duplicate(),
                    constraint: node.constraint.duplicate(),
                    default: node.default.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypeParameter(self.inner))
        }
        /// Set the `name` field and mark the builder changed.
        pub fn name(&mut self, name: &'gc Node<'gc>) { self.is_changed = true; self.inner.name = name; }
        /// Set the `constraint` field and mark the builder changed.
        pub fn constraint(&mut self, constraint: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.constraint = constraint; }
        /// Set the `default` field and mark the builder changed.
        pub fn default(&mut self, default: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.default = default; }
    }
    /// Clone-with-changes builder for [`super::TSTypeParameterInstantiation`].
    #[derive(Debug)]
    pub struct TSTypeParameterInstantiation<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypeParameterInstantiation<'gc>,
    }
    impl<'gc> TSTypeParameterInstantiation<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypeParameterInstantiation<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypeParameterInstantiation {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypeParameterInstantiation(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
    }
    /// Clone-with-changes builder for [`super::TSUnionType`].
    #[derive(Debug)]
    pub struct TSUnionType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSUnionType<'gc>,
    }
    impl<'gc> TSUnionType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSUnionType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSUnionType {
                    metadata: node.metadata.duplicate(),
                    types: node.types.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSUnionType(self.inner))
        }
        /// Set the `types` field and mark the builder changed.
        pub fn types(&mut self, types: NodeList<'gc>) { self.is_changed = true; self.inner.types = types; }
    }
    /// Clone-with-changes builder for [`super::TSIntersectionType`].
    #[derive(Debug)]
    pub struct TSIntersectionType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSIntersectionType<'gc>,
    }
    impl<'gc> TSIntersectionType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSIntersectionType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSIntersectionType {
                    metadata: node.metadata.duplicate(),
                    types: node.types.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSIntersectionType(self.inner))
        }
        /// Set the `types` field and mark the builder changed.
        pub fn types(&mut self, types: NodeList<'gc>) { self.is_changed = true; self.inner.types = types; }
    }
    /// Clone-with-changes builder for [`super::TSTypeQuery`].
    #[derive(Debug)]
    pub struct TSTypeQuery<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypeQuery<'gc>,
    }
    impl<'gc> TSTypeQuery<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypeQuery<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypeQuery {
                    metadata: node.metadata.duplicate(),
                    expr_name: node.expr_name.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypeQuery(self.inner))
        }
        /// Set the `expr_name` field and mark the builder changed.
        pub fn expr_name(&mut self, expr_name: &'gc Node<'gc>) { self.is_changed = true; self.inner.expr_name = expr_name; }
    }
    /// Clone-with-changes builder for [`super::TSConditionalType`].
    #[derive(Debug)]
    pub struct TSConditionalType<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSConditionalType<'gc>,
    }
    impl<'gc> TSConditionalType<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSConditionalType<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSConditionalType {
                    metadata: node.metadata.duplicate(),
                    check_type: node.check_type.duplicate(),
                    extends_type: node.extends_type.duplicate(),
                    true_type: node.true_type.duplicate(),
                    false_type: node.false_type.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSConditionalType(self.inner))
        }
        /// Set the `check_type` field and mark the builder changed.
        pub fn check_type(&mut self, check_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.check_type = check_type; }
        /// Set the `extends_type` field and mark the builder changed.
        pub fn extends_type(&mut self, extends_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.extends_type = extends_type; }
        /// Set the `true_type` field and mark the builder changed.
        pub fn true_type(&mut self, true_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.true_type = true_type; }
        /// Set the `false_type` field and mark the builder changed.
        pub fn false_type(&mut self, false_type: &'gc Node<'gc>) { self.is_changed = true; self.inner.false_type = false_type; }
    }
    /// Clone-with-changes builder for [`super::TSTypeLiteral`].
    #[derive(Debug)]
    pub struct TSTypeLiteral<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSTypeLiteral<'gc>,
    }
    impl<'gc> TSTypeLiteral<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSTypeLiteral<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSTypeLiteral {
                    metadata: node.metadata.duplicate(),
                    members: node.members.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSTypeLiteral(self.inner))
        }
        /// Set the `members` field and mark the builder changed.
        pub fn members(&mut self, members: NodeList<'gc>) { self.is_changed = true; self.inner.members = members; }
    }
    /// Clone-with-changes builder for [`super::TSPropertySignature`].
    #[derive(Debug)]
    pub struct TSPropertySignature<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSPropertySignature<'gc>,
    }
    impl<'gc> TSPropertySignature<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSPropertySignature<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSPropertySignature {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                    initializer: node.initializer.duplicate(),
                    optional: Cell::new(node.optional.get()),
                    computed: Cell::new(node.computed.get()),
                    readonly: Cell::new(node.readonly.get()),
                    r#static: Cell::new(node.r#static.get()),
                    export: Cell::new(node.export.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSPropertySignature(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
        /// Set the `initializer` field and mark the builder changed.
        pub fn initializer(&mut self, initializer: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.initializer = initializer; }
    }
    /// Clone-with-changes builder for [`super::TSMethodSignature`].
    #[derive(Debug)]
    pub struct TSMethodSignature<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSMethodSignature<'gc>,
    }
    impl<'gc> TSMethodSignature<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSMethodSignature<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSMethodSignature {
                    metadata: node.metadata.duplicate(),
                    key: node.key.duplicate(),
                    params: node.params.duplicate(),
                    return_type: node.return_type.duplicate(),
                    computed: Cell::new(node.computed.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSMethodSignature(self.inner))
        }
        /// Set the `key` field and mark the builder changed.
        pub fn key(&mut self, key: &'gc Node<'gc>) { self.is_changed = true; self.inner.key = key; }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.return_type = return_type; }
    }
    /// Clone-with-changes builder for [`super::TSIndexSignature`].
    #[derive(Debug)]
    pub struct TSIndexSignature<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSIndexSignature<'gc>,
    }
    impl<'gc> TSIndexSignature<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSIndexSignature<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSIndexSignature {
                    metadata: node.metadata.duplicate(),
                    parameters: node.parameters.duplicate(),
                    type_annotation: node.type_annotation.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSIndexSignature(self.inner))
        }
        /// Set the `parameters` field and mark the builder changed.
        pub fn parameters(&mut self, parameters: NodeList<'gc>) { self.is_changed = true; self.inner.parameters = parameters; }
        /// Set the `type_annotation` field and mark the builder changed.
        pub fn type_annotation(&mut self, type_annotation: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.type_annotation = type_annotation; }
    }
    /// Clone-with-changes builder for [`super::TSCallSignatureDeclaration`].
    #[derive(Debug)]
    pub struct TSCallSignatureDeclaration<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSCallSignatureDeclaration<'gc>,
    }
    impl<'gc> TSCallSignatureDeclaration<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSCallSignatureDeclaration<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSCallSignatureDeclaration {
                    metadata: node.metadata.duplicate(),
                    params: node.params.duplicate(),
                    return_type: node.return_type.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSCallSignatureDeclaration(self.inner))
        }
        /// Set the `params` field and mark the builder changed.
        pub fn params(&mut self, params: NodeList<'gc>) { self.is_changed = true; self.inner.params = params; }
        /// Set the `return_type` field and mark the builder changed.
        pub fn return_type(&mut self, return_type: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.return_type = return_type; }
    }
    /// Clone-with-changes builder for [`super::TSModifiers`].
    #[derive(Debug)]
    pub struct TSModifiers<'gc> {
        is_changed: bool,
        pub(super) inner: super::TSModifiers<'gc>,
    }
    impl<'gc> TSModifiers<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::TSModifiers<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::TSModifiers {
                    metadata: node.metadata.duplicate(),
                    accessibility: Cell::new(node.accessibility.get()),
                    readonly: Cell::new(node.readonly.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::TSModifiers(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::CoverEmptyArgs`].
    #[derive(Debug)]
    pub struct CoverEmptyArgs<'gc> {
        is_changed: bool,
        pub(super) inner: super::CoverEmptyArgs<'gc>,
    }
    impl<'gc> CoverEmptyArgs<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::CoverEmptyArgs<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::CoverEmptyArgs {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::CoverEmptyArgs(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::CoverTrailingComma`].
    #[derive(Debug)]
    pub struct CoverTrailingComma<'gc> {
        is_changed: bool,
        pub(super) inner: super::CoverTrailingComma<'gc>,
    }
    impl<'gc> CoverTrailingComma<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::CoverTrailingComma<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::CoverTrailingComma {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::CoverTrailingComma(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::CoverInitializer`].
    #[derive(Debug)]
    pub struct CoverInitializer<'gc> {
        is_changed: bool,
        pub(super) inner: super::CoverInitializer<'gc>,
    }
    impl<'gc> CoverInitializer<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::CoverInitializer<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::CoverInitializer {
                    metadata: node.metadata.duplicate(),
                    init: node.init.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::CoverInitializer(self.inner))
        }
        /// Set the `init` field and mark the builder changed.
        pub fn init(&mut self, init: &'gc Node<'gc>) { self.is_changed = true; self.inner.init = init; }
    }
    /// Clone-with-changes builder for [`super::CoverRestElement`].
    #[derive(Debug)]
    pub struct CoverRestElement<'gc> {
        is_changed: bool,
        pub(super) inner: super::CoverRestElement<'gc>,
    }
    impl<'gc> CoverRestElement<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::CoverRestElement<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::CoverRestElement {
                    metadata: node.metadata.duplicate(),
                    rest: node.rest.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::CoverRestElement(self.inner))
        }
        /// Set the `rest` field and mark the builder changed.
        pub fn rest(&mut self, rest: &'gc Node<'gc>) { self.is_changed = true; self.inner.rest = rest; }
    }
    /// Clone-with-changes builder for [`super::CoverTypedIdentifier`].
    #[derive(Debug)]
    pub struct CoverTypedIdentifier<'gc> {
        is_changed: bool,
        pub(super) inner: super::CoverTypedIdentifier<'gc>,
    }
    impl<'gc> CoverTypedIdentifier<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::CoverTypedIdentifier<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::CoverTypedIdentifier {
                    metadata: node.metadata.duplicate(),
                    left: node.left.duplicate(),
                    right: node.right.duplicate(),
                    optional: Cell::new(node.optional.get()),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::CoverTypedIdentifier(self.inner))
        }
        /// Set the `left` field and mark the builder changed.
        pub fn left(&mut self, left: &'gc Node<'gc>) { self.is_changed = true; self.inner.left = left; }
        /// Set the `right` field and mark the builder changed.
        pub fn right(&mut self, right: Option<&'gc Node<'gc>>) { self.is_changed = true; self.inner.right = right; }
    }
    /// Clone-with-changes builder for [`super::SHBuiltin`].
    #[derive(Debug)]
    pub struct SHBuiltin<'gc> {
        is_changed: bool,
        pub(super) inner: super::SHBuiltin<'gc>,
    }
    impl<'gc> SHBuiltin<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::SHBuiltin<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::SHBuiltin {
                    metadata: node.metadata.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::SHBuiltin(self.inner))
        }
    }
    /// Clone-with-changes builder for [`super::ImplicitCheckedCast`].
    #[derive(Debug)]
    pub struct ImplicitCheckedCast<'gc> {
        is_changed: bool,
        pub(super) inner: super::ImplicitCheckedCast<'gc>,
    }
    impl<'gc> ImplicitCheckedCast<'gc> {
        /// Start from a copy of `node`, with no field changed yet.
        pub fn from_node(node: &'gc super::ImplicitCheckedCast<'gc>) -> Self {
            Self {
                is_changed: false,
                inner: super::ImplicitCheckedCast {
                    metadata: node.metadata.duplicate(),
                    argument: node.argument.duplicate(),
                },
            }
        }
        /// Allocate the rebuilt node if a setter ran, else
        /// `TransformResult::Unchanged`.
        pub fn build(self, gc: &'gc crate::context::GCLock<'_, '_>) -> TransformResult<&'gc Node<'gc>> {
            if self.is_changed {
                TransformResult::Changed(self.build_forced(gc))
            } else {
                TransformResult::Unchanged
            }
        }
        /// Allocate the node unconditionally, changed or not.
        pub fn build_forced(self, gc: &'gc crate::context::GCLock<'_, '_>) -> &'gc Node<'gc> {
            gc.alloc(Node::ImplicitCheckedCast(self.inner))
        }
        /// Set the `argument` field and mark the builder changed.
        pub fn argument(&mut self, argument: &'gc Node<'gc>) { self.is_changed = true; self.inner.argument = argument; }
    }
}