diff --git a/_scripts/generate-go-ast.ts b/_scripts/generate-go-ast.ts index 0a0f0b8ce47..114b03546ff 100644 --- a/_scripts/generate-go-ast.ts +++ b/_scripts/generate-go-ast.ts @@ -127,6 +127,7 @@ function generateHeader(w: CodeWriter) { w.write("import ("); w.push(); w.write('"sync/atomic"'); + w.write('"unsafe"'); w.write(""); w.write('"github.com/microsoft/typescript-go/internal/core"'); w.pop(); @@ -337,11 +338,22 @@ function generateBaseStructDefs(w: CodeWriter) { // ── Generate As*() cast methods ──────────────────────────────────────────── -function generateAsCast(w: CodeWriter, name: string) { - const structName = name; - w.write(`func (n *Node) As${name}() *${structName} {`); +function generateAsCast(w: CodeWriter, node: NodeType, canonicalKinds: Map) { + w.write(`func (n *Node) As${node.name}() *${node.name} {`); w.push(); - w.write(`return n.data.(*${structName})`); + w.write("switch n.Kind {"); + const kinds = canonicalKinds.get(node); + if (kinds) { + w.write(`case ${kinds.join(", ")}:`); + w.push(); + w.write(`return (*${node.name})(unsafe.Pointer(n))`); + w.pop(); + } + w.write("default:"); + w.push(); + w.write(`panic("Cannot cast " + n.Kind.String() + " to ${node.name}")`); + w.pop(); + w.write("}"); w.pop(); w.write("}"); w.write(""); @@ -349,6 +361,34 @@ function generateAsCast(w: CodeWriter, name: string) { // ── Generate New*() factory methods ──────────────────────────────────────── +function canonicalNodesByKind(): Map { + // Token's kind union overlaps the concrete identifier, literal, and keyword + // nodes. Later schema entries are the canonical representation for those + // kinds. + const nodeByKind = new Map(); + for (const node of api.nodes()) { + for (const kind of node.allKinds()) { + nodeByKind.set(kind.formatGoConstant(), node); + } + } + + const kindsByNode = new Map(); + for (const [kind, node] of nodeByKind) { + const kinds = kindsByNode.get(node); + if (kinds) { + kinds.push(kind); + } + else { + kindsByNode.set(node, [kind]); + } + } + return kindsByNode; +} + +function extendsBase(extendsKeys: string[], baseKey: string): boolean { + return extendsKeys.some(key => key === baseKey || extendsBase(api.getBase(key)?.extendsKeys ?? [], baseKey)); +} + function isNodeFlagsMember(m: MemberInfo): boolean { const type = m.type; return type.kind === "primitive" && type.name === "NodeFlags"; @@ -390,7 +430,7 @@ function emitNewFactory( const kindArg = kindMember ? kindMember.goParamName() : `Kind${kindName}`; if (nodeFlagsMembers.length > 0) { - w.write(`node := f.newNode(${kindArg}, data)`); + w.write(`node := f.newNode(${kindArg}, data.AsNode())`); for (const m of nodeFlagsMembers) { const param = m.goParamName(); if (m.bitmask) { @@ -403,7 +443,7 @@ function emitNewFactory( w.write("return node"); } else { - w.write(`return f.newNode(${kindArg}, data)`); + w.write(`return f.newNode(${kindArg}, data.AsNode())`); } w.pop(); @@ -416,7 +456,40 @@ function generateNewFactory(w: CodeWriter, node: NodeType) { const members = schemaMembers(node); const kindMember = members.find(m => m.isKindParam()); const nodeFlagsMembers = members.filter(m => isNodeFlagsMember(m)); - emitNewFactory(w, `New${node.name}`, node.syntaxKindName, structName, node, members, kindMember, nodeFlagsMembers); + + if (node.name === "Token") { + const tokenKinds = new Set(node.allKinds().map(kind => kind.formatGoConstant())); + w.write("func (f *NodeFactory) NewToken(kind TokenSyntaxKind) *Node {"); + w.push(); + w.write("switch kind {"); + for (const [canonicalNode, kinds] of canonicalNodesByKind()) { + if (canonicalNode === node) continue; + const overlappingKinds = kinds.filter(kind => tokenKinds.has(kind)); + if (overlappingKinds.length === 0) continue; + w.write(`case ${overlappingKinds.join(", ")}:`); + w.push(); + if (canonicalNode.arena) { + w.write(`data := f.${api.uncapitalize(canonicalNode.name)}Arena.New()`); + } + else { + w.write(`data := &${canonicalNode.name}{}`); + } + w.write("return f.newNode(kind, data.AsNode())"); + w.pop(); + } + w.write("default:"); + w.push(); + w.write("data := f.tokenArena.New()"); + w.write("return f.newNode(kind, data.AsNode())"); + w.pop(); + w.write("}"); + w.pop(); + w.write("}"); + w.write(""); + } + else { + emitNewFactory(w, `New${node.name}`, node.syntaxKindName, structName, node, members, kindMember, nodeFlagsMembers); + } for (const alias of node.kindAliases) { emitNewFactory(w, `New${alias}`, alias, structName, node, members, kindMember, nodeFlagsMembers); } @@ -569,14 +642,10 @@ function hasForEachChild(node: NodeType): boolean { // Generates a (*Node).ForEachChild method that dispatches on node.Kind to the // concrete node type's ForEachChild method. // -// This deliberately avoids calling node.data.ForEachChild(v) through the -// nodeData interface. An interface (or other indirect) call is opaque to escape -// analysis, which must then assume the visitor `v` escapes; that forces caller -// closures — and any locals they capture — onto the heap. Dispatching through a -// Kind switch to a statically-resolved concrete method lets escape analysis -// prove the visitor does not escape, keeping caller closures on the stack. The -// integer switch over Kind also compiles to a jump table, making dispatch -// cheaper than the interface call it replaces. +// Dispatching through a Kind switch to a statically-resolved concrete method +// lets escape analysis prove the visitor does not escape, keeping caller +// closures on the stack. The integer switch over Kind also compiles to a jump +// table. // // Kinds whose node has no children fall through to `default` and return false, // matching NodeDefault.ForEachChild. @@ -590,7 +659,7 @@ function generateForEachChildDispatch(w: CodeWriter) { if (kinds.length === 0) continue; w.write(`case ${kinds.join(", ")}:`); w.push(); - w.write(`return n.data.(*${node.name}).ForEachChild(v)`); + w.write(`return (*${node.name})(unsafe.Pointer(n)).ForEachChild(v)`); w.pop(); } w.write("default:"); @@ -603,6 +672,275 @@ function generateForEachChildDispatch(w: CodeWriter) { w.write(""); } +function generateVisitEachChildDispatch(w: CodeWriter) { + w.write("func (n *Node) VisitEachChild(v *NodeVisitor) *Node {"); + w.push(); + w.write("switch n.Kind {"); + for (const node of api.nodes()) { + if (!hasForEachChild(node)) continue; + const kinds = node.allKinds().map(k => k.formatGoConstant()); + if (kinds.length === 0) continue; + w.write(`case ${kinds.join(", ")}:`); + w.push(); + w.write(`return (*${node.name})(unsafe.Pointer(n)).VisitEachChild(v)`); + w.pop(); + } + w.write("default:"); + w.push(); + w.write("return n"); + w.pop(); + w.write("}"); + w.pop(); + w.write("}"); + w.write(""); +} + +function generateSubtreeFactsDispatch(w: CodeWriter) { + w.write("func (n *Node) SubtreeFacts() SubtreeFacts {"); + w.push(); + w.write("switch n.Kind {"); + w.write("case kindFlowSwitchClauseData:"); + w.push(); + w.write("return SubtreeFactsNone"); + w.pop(); + w.write("case kindFlowReduceLabelData:"); + w.push(); + w.write("return SubtreeFactsNone"); + w.pop(); + for (const [node, kinds] of canonicalNodesByKind()) { + w.write(`case ${kinds.join(", ")}:`); + w.push(); + if (extendsBase(node.extendsKeys, "CompositeBase")) { + w.write(`data := (*${node.name})(unsafe.Pointer(n))`); + w.write("return data.subtreeFactsWorker(data.AsNode())"); + } + else { + w.write(`return (*${node.name})(unsafe.Pointer(n)).computeSubtreeFacts()`); + } + w.pop(); + } + w.write("default:"); + w.push(); + w.write('panic("Unhandled case in Node.SubtreeFacts: " + n.Kind.String())'); + w.pop(); + w.write("}"); + w.pop(); + w.write("}"); + w.write(""); +} + +function generatePropagateSubtreeFactsDispatch(w: CodeWriter) { + const exclusions = new Map([ + ["KindCatchClause", "SubtreeExclusionsCatchClause"], + ["KindVariableDeclarationList", "SubtreeExclusionsVariableDeclarationList"], + ["KindObjectBindingPattern", "SubtreeExclusionsBindingPattern"], + ["KindArrayBindingPattern", "SubtreeExclusionsBindingPattern"], + ["KindParameter", "SubtreeExclusionsParameter"], + ["KindFunctionDeclaration", "SubtreeExclusionsFunction"], + ["KindClassDeclaration", "SubtreeExclusionsClass"], + ["KindClassExpression", "SubtreeExclusionsClass"], + ["KindModuleDeclaration", "SubtreeExclusionsModule"], + ["KindConstructor", "SubtreeExclusionsConstructor"], + ["KindArrowFunction", "SubtreeExclusionsArrowFunction"], + ["KindFunctionExpression", "SubtreeExclusionsFunction"], + ["KindAsExpression", "SubtreeExclusionsOuterExpression"], + ["KindSatisfiesExpression", "SubtreeExclusionsOuterExpression"], + ["KindPropertyAccessExpression", "SubtreeExclusionsPropertyAccess"], + ["KindElementAccessExpression", "SubtreeExclusionsElementAccess"], + ["KindCallExpression", "SubtreeExclusionsCall"], + ["KindNewExpression", "SubtreeExclusionsNew"], + ["KindArrayLiteralExpression", "SubtreeExclusionsArrayLiteral"], + ["KindObjectLiteralExpression", "SubtreeExclusionsObjectLiteral"], + ["KindTypeAssertionExpression", "SubtreeExclusionsOuterExpression"], + ]); + w.write("var nodePropagateSubtreeFactsExclusions = [KindCount]SubtreeFacts{"); + w.push(); + for (const [kind, exclusion] of exclusions) { + w.write(`${kind}: ${exclusion},`); + } + w.pop(); + w.write("}"); + w.write(""); + w.write("func (n *Node) propagateSubtreeFacts() SubtreeFacts {"); + w.push(); + w.write("facts := n.SubtreeFacts()"); + w.write("switch n.Kind {"); + w.write("case KindGetAccessor, KindSetAccessor:"); + w.push(); + w.write("return facts & ^SubtreeExclusionsAccessor | propagateSubtreeFacts(n.Name())"); + w.pop(); + w.write("case KindMethodDeclaration:"); + w.push(); + w.write("return facts & ^SubtreeExclusionsMethod | propagateSubtreeFacts(n.Name())"); + w.pop(); + w.write("case KindPropertyDeclaration:"); + w.push(); + w.write("return facts & ^SubtreeExclusionsProperty | propagateSubtreeFacts(n.Name())"); + w.pop(); + w.write("}"); + w.write("kind := uint16(n.Kind)"); + w.write("if kind >= uint16(len(nodePropagateSubtreeFactsExclusions)) {"); + w.push(); + w.write("return facts"); + w.pop(); + w.write("}"); + w.write("return facts & ^nodePropagateSubtreeFactsExclusions[kind]"); + w.pop(); + w.write("}"); + w.write(""); +} + +function generateComputeSubtreeFactsDispatch(w: CodeWriter) { + generateNodeDataAccessorDispatch(w, "computeSubtreeFacts", "SubtreeFacts", () => true, "SubtreeFactsNone"); +} + +function generateNodeDataAccessorDispatch( + w: CodeWriter, + methodName: string, + returnType: string, + handlesNode: (node: NodeType) => boolean, + defaultValue: string, +) { + w.write(`func (n *Node) ${methodName}() ${returnType} {`); + w.push(); + w.write("switch n.Kind {"); + for (const [node, kinds] of canonicalNodesByKind()) { + if (!handlesNode(node)) continue; + w.write(`case ${kinds.join(", ")}:`); + w.push(); + w.write(`return (*${node.name})(unsafe.Pointer(n)).${methodName}()`); + w.pop(); + } + w.write("default:"); + w.push(); + w.write(`return ${defaultValue}`); + w.pop(); + w.write("}"); + w.pop(); + w.write("}"); + w.write(""); +} + +function generateNodeOffsetAccessorDispatch( + w: CodeWriter, + methodName: string, + returnType: string, + selector: string | ((node: NodeType) => string), + handlesNode: (node: NodeType) => boolean, + indirect: boolean, + unsupported = "return nil", + directIndex = false, + handlesKind: (kind: string) => boolean = () => true, +) { + const offsetsName = `node${methodName}Offsets`; + const tableLength = directIndex ? "kindFlowReduceLabelData + 1" : "KindCount"; + w.write(`var ${offsetsName} = [${tableLength}]uint16{`); + w.push(); + for (const [node, kinds] of canonicalNodesByKind()) { + if (!handlesNode(node)) continue; + for (const kind of kinds) { + if (!handlesKind(kind)) continue; + const nodeSelector = typeof selector === "string" ? selector : selector(node); + w.write(`${kind}: uint16(unsafe.Offsetof(${node.name}{}.${nodeSelector})) + 1,`); + } + } + w.pop(); + w.write("}"); + w.write(""); + w.write(`func (n *Node) ${methodName}() ${returnType} {`); + w.push(); + const kind = directIndex ? "n.Kind" : "kind"; + if (!directIndex) { + w.write("kind := uint16(n.Kind)"); + w.write(`if ${kind} >= uint16(len(${offsetsName})) {`); + w.push(); + w.write(unsupported); + w.pop(); + w.write("}"); + } + w.write(`offset := ${offsetsName}[${kind}]`); + w.write("if offset == 0 {"); + w.push(); + w.write(unsupported); + w.pop(); + w.write("}"); + const pointer = "unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))"; + if (indirect) { + w.write(`return *(*${returnType})(${pointer})`); + } + else { + w.write(`return (${returnType})(${pointer})`); + } + w.pop(); + w.write("}"); + w.write(""); +} + +function generateNodeTextOffsets(w: CodeWriter) { + w.write("var nodeTextOffsets = [kindFlowReduceLabelData + 1]uint16{"); + w.push(); + for (const [node, kinds] of canonicalNodesByKind()) { + const hasText = schemaMembers(node).some(m => + m.name === "Text" && + m.type.kind === "primitive" && + m.type.name === "string" + ) && node.name !== "JsxText"; + if (!hasText) continue; + for (const kind of kinds) { + w.write(`${kind}: uint16(unsafe.Offsetof(${node.name}{}.Text)) + 1,`); + } + } + w.pop(); + w.write("}"); + w.write(""); +} + +function generateCloneDispatch(w: CodeWriter) { + w.write("func (n *Node) Clone(f NodeFactoryCoercible) *Node {"); + w.push(); + w.write("switch n.Kind {"); + w.write("case kindFlowSwitchClauseData, kindFlowReduceLabelData:"); + w.push(); + w.write("return nil"); + w.pop(); + for (const [node, kinds] of canonicalNodesByKind()) { + w.write(`case ${kinds.join(", ")}:`); + w.push(); + w.write(`return (*${node.name})(unsafe.Pointer(n)).Clone(f)`); + w.pop(); + } + w.write("default:"); + w.push(); + w.write('panic("Unhandled case in Node.Clone: " + n.Kind.String())'); + w.pop(); + w.write("}"); + w.pop(); + w.write("}"); + w.write(""); +} + +function generateSetModifiersDispatch(w: CodeWriter) { + w.write("func (n *MutableNode) SetModifiers(modifiers *ModifierList) {"); + w.push(); + w.write("node := (*Node)(unsafe.Pointer(n))"); + w.write("kind := uint16(node.Kind)"); + w.write("if kind >= uint16(len(nodeModifiersOffsets)) {"); + w.push(); + w.write('panic("Cannot set modifiers on " + node.Kind.String())'); + w.pop(); + w.write("}"); + w.write("offset := nodeModifiersOffsets[kind]"); + w.write("if offset == 0 {"); + w.push(); + w.write('panic("Cannot set modifiers on " + node.Kind.String())'); + w.pop(); + w.write("}"); + w.write("*(**ModifierList)(unsafe.Add(unsafe.Pointer(node), uintptr(offset-1))) = modifiers"); + w.pop(); + w.write("}"); + w.write(""); +} + // ── Generate VisitEachChild() ────────────────────────────────────────────── function generateVisitEachChild(w: CodeWriter, node: NodeType) { @@ -951,13 +1289,81 @@ function generate(): string { w.write(""); generateForEachChildDispatch(w); + // VisitEachChild dispatch + w.write("// ──────────────────────────────────────────────────────────────────────"); + w.write("// VisitEachChild dispatch"); + w.write("// ──────────────────────────────────────────────────────────────────────"); + w.write(""); + generateVisitEachChildDispatch(w); + + // SubtreeFacts dispatch + w.write("// ──────────────────────────────────────────────────────────────────────"); + w.write("// SubtreeFacts dispatch"); + w.write("// ──────────────────────────────────────────────────────────────────────"); + w.write(""); + generateSubtreeFactsDispatch(w); + + // Compute subtree facts dispatch + w.write("// ──────────────────────────────────────────────────────────────────────"); + w.write("// Compute subtree facts dispatch"); + w.write("// ──────────────────────────────────────────────────────────────────────"); + w.write(""); + generateComputeSubtreeFactsDispatch(w); + + // Node data accessor dispatch + w.write("// ──────────────────────────────────────────────────────────────────────"); + w.write("// Node data accessor dispatch"); + w.write("// ──────────────────────────────────────────────────────────────────────"); + w.write(""); + generateNodeOffsetAccessorDispatch(w, "Name", "*DeclarationName", "name", node => schemaMembers(node).some(m => m.name === "name"), true); + generateNodeOffsetAccessorDispatch(w, "Modifiers", "*ModifierList", "modifiers", node => extendsBase(node.extendsKeys, "ModifiersBase"), true); + generateNodeOffsetAccessorDispatch(w, "FlowNodeData", "*FlowNodeBase", "FlowNodeBase", node => extendsBase(node.extendsKeys, "FlowNodeBase"), false); + generateNodeOffsetAccessorDispatch(w, "DeclarationData", "*DeclarationBase", "DeclarationBase", node => extendsBase(node.extendsKeys, "DeclarationBase"), false); + generateNodeOffsetAccessorDispatch(w, "LocalsContainerData", "*LocalsContainerBase", "LocalsContainerBase", node => extendsBase(node.extendsKeys, "LocalsContainerBase"), false); + generateNodeOffsetAccessorDispatch(w, "FunctionLikeData", "*FunctionLikeBase", "FunctionLikeBase", node => extendsBase(node.extendsKeys, "FunctionLikeBase"), false); + generateNodeOffsetAccessorDispatch( + w, + "Expression", + "*Node", + "Expression", + node => + schemaMembers(node).some(m => m.name === "Expression") && + node.name !== "TypeParameterDeclaration" && + node.name !== "SyntheticReferenceExpression", + true, + "return n.expressionUnsupported()", + true, + kind => kind !== "KindDefaultClause", + ); + generateNodeOffsetAccessorDispatch( + w, + "Type", + "*Node", + node => schemaMembers(node).some(m => m.name === "Type") ? "Type" : "TypeExpression", + node => + (schemaMembers(node).some(m => m.name === "Type") && node.name !== "SyntheticExpression" && node.name !== "JSDocVariadicType") || + node.name === "JSDocParameterOrPropertyTag", + true, + ); + generateNodeOffsetAccessorDispatch(w, "Initializer", "*Node", "Initializer", node => schemaMembers(node).some(m => m.name === "Initializer"), true, 'panic("Unhandled case in Node.Initializer")'); + generateNodeTextOffsets(w); + generatePropagateSubtreeFactsDispatch(w); + generateNodeOffsetAccessorDispatch(w, "ExportableData", "*ExportableBase", "ExportableBase", node => extendsBase(node.extendsKeys, "ExportableBase"), false); + generateNodeOffsetAccessorDispatch(w, "ClassLikeData", "*ClassLikeBase", "ClassLikeBase", node => extendsBase(node.extendsKeys, "ClassLikeBase"), false); + generateNodeOffsetAccessorDispatch(w, "BodyData", "*BodyBase", "BodyBase", node => extendsBase(node.extendsKeys, "BodyBase"), false); + generateNodeOffsetAccessorDispatch(w, "LiteralLikeData", "*LiteralLikeNodeBase", "LiteralLikeNodeBase", node => extendsBase(node.extendsKeys, "LiteralLikeNodeBase"), false); + generateNodeOffsetAccessorDispatch(w, "TemplateLiteralLikeData", "*TemplateLiteralLikeNodeBase", "TemplateLiteralLikeNodeBase", node => extendsBase(node.extendsKeys, "TemplateLiteralLikeNodeBase"), false); + generateCloneDispatch(w); + generateSetModifiersDispatch(w); + // As*() casts w.write("// ──────────────────────────────────────────────────────────────────────"); w.write("// As*() cast methods"); w.write("// ──────────────────────────────────────────────────────────────────────"); w.write(""); + const canonicalKinds = canonicalNodesByKind(); for (const node of api.nodes()) { - generateAsCast(w, node.name); + generateAsCast(w, node, canonicalKinds); } // Kind alias guards diff --git a/internal/ast/ast.go b/internal/ast/ast.go index fad3777fef0..f8a1fd1546a 100644 --- a/internal/ast/ast.go +++ b/internal/ast/ast.go @@ -6,6 +6,7 @@ import ( "strings" "sync" "sync/atomic" + "unsafe" "github.com/microsoft/typescript-go/internal/collections" "github.com/microsoft/typescript-go/internal/core" @@ -70,20 +71,18 @@ func NewNodeFactory(hooks NodeFactoryHooks) *NodeFactory { return &NodeFactory{hooks: hooks} } -func newNode(kind Kind, data nodeData, hooks NodeFactoryHooks) *Node { - n := data.AsNode() +func newNode(kind Kind, n *Node, hooks NodeFactoryHooks) *Node { n.Loc = core.UndefinedTextRange() n.Kind = kind - n.data = data if hooks.OnCreate != nil { hooks.OnCreate(n) } return n } -func (f *NodeFactory) newNode(kind Kind, data nodeData) *Node { +func (f *NodeFactory) newNode(kind Kind, node *Node) *Node { f.nodeCount++ - return newNode(kind, data, f.hooks) + return newNode(kind, node, f.hooks) } func (f *NodeFactory) NodeCount() int { @@ -181,7 +180,6 @@ type Node struct { Loc core.TextRange id atomic.Uint64 Parent *Node - data nodeData } // Node accessors. Some accessors are implemented as methods on NodeData, others are implemented though @@ -192,38 +190,18 @@ func (n *Node) AsNode() *Node { return n } func (n *Node) Pos() int { return n.Loc.Pos() } func (n *Node) End() int { return n.Loc.End() } func (n *Node) IterChildren() iter.Seq[*Node] { - // Implemented directly (rather than through the nodeData interface) so that the - // returned iterator and the visitor closure it passes to ForEachChild do not - // escape: an interface call is opaque to escape analysis. `true` stops a TS - // visitor early, whereas `false` stops a Go iterator yield, so the result is - // inverted. + // `true` stops a TS visitor early, whereas `false` stops a Go iterator yield, + // so the result is inverted. return func(yield func(*Node) bool) { n.ForEachChild(func(child *Node) bool { return !yield(child) }) } } -func (n *Node) Clone(f NodeFactoryCoercible) *Node { return n.data.Clone(f) } -func (n *Node) VisitEachChild(v *NodeVisitor) *Node { return n.data.VisitEachChild(v) } -func (n *Node) Name() *DeclarationName { return n.data.Name() } -func (n *Node) Modifiers() *ModifierList { return n.data.Modifiers() } -func (n *Node) FlowNodeData() *FlowNodeBase { return n.data.FlowNodeData() } -func (n *Node) DeclarationData() *DeclarationBase { return n.data.DeclarationData() } -func (n *Node) ExportableData() *ExportableBase { return n.data.ExportableData() } -func (n *Node) LocalsContainerData() *LocalsContainerBase { return n.data.LocalsContainerData() } -func (n *Node) FunctionLikeData() *FunctionLikeBase { return n.data.FunctionLikeData() } -func (n *Node) ParameterList() *ParameterList { return n.data.FunctionLikeData().Parameters } -func (n *Node) Parameters() []*ParameterDeclarationNode { return n.ParameterList().Nodes } -func (n *Node) ClassLikeData() *ClassLikeBase { return n.data.ClassLikeData() } -func (n *Node) BodyData() *BodyBase { return n.data.BodyData() } -func (n *Node) SubtreeFacts() SubtreeFacts { return n.data.SubtreeFacts() } -func (n *Node) propagateSubtreeFacts() SubtreeFacts { return n.data.propagateSubtreeFacts() } -func (n *Node) LiteralLikeData() *LiteralLikeNodeBase { return n.data.LiteralLikeData() } -func (n *Node) TemplateLiteralLikeData() *TemplateLiteralLikeNodeBase { - return n.data.TemplateLiteralLikeData() -} -func (n *Node) KindString() string { return n.Kind.String() } -func (n *Node) KindValue() int16 { return int16(n.Kind) } +func (n *Node) ParameterList() *ParameterList { return n.FunctionLikeData().Parameters } +func (n *Node) Parameters() []*ParameterDeclarationNode { return n.ParameterList().Nodes } +func (n *Node) KindString() string { return n.Kind.String() } +func (n *Node) KindValue() int16 { return int16(n.Kind) } func (n *Node) Decorators() []*Node { if n.Modifiers() == nil { return nil @@ -233,8 +211,7 @@ func (n *Node) Decorators() []*Node { type MutableNode Node -func (n *Node) AsMutable() *MutableNode { return (*MutableNode)(n) } -func (n *MutableNode) SetModifiers(modifiers *ModifierList) { n.data.setModifiers(modifiers) } +func (n *Node) AsMutable() *MutableNode { return (*MutableNode)(n) } func (n *Node) Symbol() *Symbol { data := n.DeclarationData() @@ -269,31 +246,24 @@ func (n *Node) Body() *Node { } func (n *Node) Text() string { + offset := nodeTextOffsets[n.Kind] + if offset != 0 { + return *(*string)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) + } + return n.textSlow() +} + +//go:noinline +func (n *Node) expressionUnsupported() *Node { + panic("Unhandled case in Node.Expression: " + n.Kind.String()) +} + +func (n *Node) textSlow() string { switch n.Kind { - case KindIdentifier: - return n.AsIdentifier().Text - case KindPrivateIdentifier: - return n.AsPrivateIdentifier().Text - case KindStringLiteral: - return n.AsStringLiteral().Text - case KindNumericLiteral: - return n.AsNumericLiteral().Text - case KindBigIntLiteral: - return n.AsBigIntLiteral().Text case KindMetaProperty: return n.AsMetaProperty().Name().Text() - case KindNoSubstitutionTemplateLiteral: - return n.AsNoSubstitutionTemplateLiteral().Text - case KindTemplateHead: - return n.AsTemplateHead().Text - case KindTemplateMiddle: - return n.AsTemplateMiddle().Text - case KindTemplateTail: - return n.AsTemplateTail().Text case KindJsxNamespacedName: return n.AsJsxNamespacedName().Namespace.Text() + ":" + n.AsJsxNamespacedName().name.Text() - case KindRegularExpressionLiteral: - return n.AsRegularExpressionLiteral().Text case KindJSDocText: return strings.Join(n.AsJSDocText().text, "") case KindJSDocLink: @@ -303,83 +273,7 @@ func (n *Node) Text() string { case KindJSDocLinkPlain: return strings.Join(n.AsJSDocLinkPlain().text, "") } - panic(fmt.Sprintf("Unhandled case in Node.Text: %T", n.data)) -} - -func (n *Node) Expression() *Node { - switch n.Kind { - case KindPropertyAccessExpression: - return n.AsPropertyAccessExpression().Expression - case KindElementAccessExpression: - return n.AsElementAccessExpression().Expression - case KindParenthesizedExpression: - return n.AsParenthesizedExpression().Expression - case KindCallExpression: - return n.AsCallExpression().Expression - case KindNewExpression: - return n.AsNewExpression().Expression - case KindExpressionWithTypeArguments: - return n.AsExpressionWithTypeArguments().Expression - case KindComputedPropertyName: - return n.AsComputedPropertyName().Expression - case KindNonNullExpression: - return n.AsNonNullExpression().Expression - case KindTypeAssertionExpression: - return n.AsTypeAssertion().Expression - case KindAsExpression: - return n.AsAsExpression().Expression - case KindSatisfiesExpression: - return n.AsSatisfiesExpression().Expression - case KindTypeOfExpression: - return n.AsTypeOfExpression().Expression - case KindSpreadAssignment: - return n.AsSpreadAssignment().Expression - case KindSpreadElement: - return n.AsSpreadElement().Expression - case KindTemplateSpan: - return n.AsTemplateSpan().Expression - case KindDeleteExpression: - return n.AsDeleteExpression().Expression - case KindVoidExpression: - return n.AsVoidExpression().Expression - case KindAwaitExpression: - return n.AsAwaitExpression().Expression - case KindYieldExpression: - return n.AsYieldExpression().Expression - case KindPartiallyEmittedExpression: - return n.AsPartiallyEmittedExpression().Expression - case KindIfStatement: - return n.AsIfStatement().Expression - case KindDoStatement: - return n.AsDoStatement().Expression - case KindWhileStatement: - return n.AsWhileStatement().Expression - case KindWithStatement: - return n.AsWithStatement().Expression - case KindForInStatement, KindForOfStatement: - return n.AsForInOrOfStatement().Expression - case KindSwitchStatement: - return n.AsSwitchStatement().Expression - case KindCaseClause: - return n.AsCaseOrDefaultClause().Expression - case KindExpressionStatement: - return n.AsExpressionStatement().Expression - case KindReturnStatement: - return n.AsReturnStatement().Expression - case KindThrowStatement: - return n.AsThrowStatement().Expression - case KindExternalModuleReference: - return n.AsExternalModuleReference().Expression - case KindExportAssignment: - return n.AsExportAssignment().Expression - case KindDecorator: - return n.AsDecorator().Expression - case KindJsxExpression: - return n.AsJsxExpression().Expression - case KindJsxSpreadAttribute: - return n.AsJsxSpreadAttribute().Expression - } - panic("Unhandled case in Node.Expression: " + n.Kind.String()) + panic("Unhandled case in Node.Text: " + n.Kind.String()) } func (n *Node) RawText() string { @@ -624,66 +518,6 @@ func (n *Node) ModifierNodes() []*Node { return nil } -func (n *Node) Type() *Node { - switch n.Kind { - case KindVariableDeclaration: - return n.AsVariableDeclaration().Type - case KindParameter: - return n.AsParameterDeclaration().Type - case KindPropertySignature: - return n.AsPropertySignatureDeclaration().Type - case KindPropertyDeclaration: - return n.AsPropertyDeclaration().Type - case KindPropertyAssignment: - return n.AsPropertyAssignment().Type - case KindShorthandPropertyAssignment: - return n.AsShorthandPropertyAssignment().Type - case KindTypePredicate: - return n.AsTypePredicateNode().Type - case KindParenthesizedType: - return n.AsParenthesizedTypeNode().Type - case KindTypeOperator: - return n.AsTypeOperatorNode().Type - case KindMappedType: - return n.AsMappedTypeNode().Type - case KindTypeAssertionExpression: - return n.AsTypeAssertion().Type - case KindAsExpression: - return n.AsAsExpression().Type - case KindSatisfiesExpression: - return n.AsSatisfiesExpression().Type - case KindTypeAliasDeclaration, KindJSTypeAliasDeclaration: - return n.AsTypeAliasDeclaration().Type - case KindNamedTupleMember: - return n.AsNamedTupleMember().Type - case KindOptionalType: - return n.AsOptionalTypeNode().Type - case KindRestType: - return n.AsRestTypeNode().Type - case KindTemplateLiteralTypeSpan: - return n.AsTemplateLiteralTypeSpan().Type - case KindJSDocTypeExpression: - return n.AsJSDocTypeExpression().Type - case KindJSDocParameterTag, KindJSDocPropertyTag: - return n.AsJSDocParameterOrPropertyTag().TypeExpression - case KindJSDocNullableType: - return n.AsJSDocNullableType().Type - case KindJSDocNonNullableType: - return n.AsJSDocNonNullableType().Type - case KindJSDocOptionalType: - return n.AsJSDocOptionalType().Type - case KindExportAssignment: - return n.AsExportAssignment().Type - case KindBinaryExpression: - return n.AsBinaryExpression().Type - default: - if funcLike := n.FunctionLikeData(); funcLike != nil { - return funcLike.Type - } - } - return nil -} - func (m *MutableNode) SetType(t *Node) { n := (*Node)(m) switch m.Kind { @@ -746,32 +580,6 @@ func (m *MutableNode) SetType(t *Node) { } } -func (n *Node) Initializer() *Node { - switch n.Kind { - case KindVariableDeclaration: - return n.AsVariableDeclaration().Initializer - case KindParameter: - return n.AsParameterDeclaration().Initializer - case KindBindingElement: - return n.AsBindingElement().Initializer - case KindPropertyDeclaration: - return n.AsPropertyDeclaration().Initializer - case KindPropertySignature: - return n.AsPropertySignatureDeclaration().Initializer - case KindPropertyAssignment: - return n.AsPropertyAssignment().Initializer - case KindEnumMember: - return n.AsEnumMember().Initializer - case KindForStatement: - return n.AsForStatement().Initializer - case KindForInStatement, KindForOfStatement: - return n.AsForInOrOfStatement().Initializer - case KindJsxAttribute: - return n.AsJsxAttribute().Initializer - } - panic("Unhandled case in Node.Initializer") -} - func (m *MutableNode) SetInitializer(initializer *Node) { n := (*Node)(m) switch n.Kind { @@ -1168,36 +976,17 @@ func (n *Node) Contains(descendant *Node) bool { // Node casts func (n *Node) AsFlowSwitchClauseData() *FlowSwitchClauseData { - return n.data.(*FlowSwitchClauseData) + if n.Kind != kindFlowSwitchClauseData { + panic("Cannot cast " + n.Kind.String() + " to FlowSwitchClauseData") + } + return (*FlowSwitchClauseData)(unsafe.Pointer(n)) } func (n *Node) AsFlowReduceLabelData() *FlowReduceLabelData { - return n.data.(*FlowReduceLabelData) -} - -// NodeData - -type nodeData interface { - AsNode() *Node - ForEachChild(v Visitor) bool - VisitEachChild(v *NodeVisitor) *Node - Clone(v NodeFactoryCoercible) *Node - Name() *DeclarationName - Modifiers() *ModifierList - setModifiers(modifiers *ModifierList) - FlowNodeData() *FlowNodeBase - DeclarationData() *DeclarationBase - ExportableData() *ExportableBase - LocalsContainerData() *LocalsContainerBase - FunctionLikeData() *FunctionLikeBase - ClassLikeData() *ClassLikeBase - BodyData() *BodyBase - LiteralLikeData() *LiteralLikeNodeBase - TemplateLiteralLikeData() *TemplateLiteralLikeNodeBase - SubtreeFacts() SubtreeFacts - computeSubtreeFacts() SubtreeFacts - subtreeFactsWorker(self nodeData) SubtreeFacts - propagateSubtreeFacts() SubtreeFacts + if n.Kind != kindFlowReduceLabelData { + panic("Cannot cast " + n.Kind.String() + " to FlowReduceLabelData") + } + return (*FlowReduceLabelData)(unsafe.Pointer(n)) } // NodeDefault @@ -1224,14 +1013,13 @@ func (node *NodeDefault) BodyData() *BodyBase func (node *NodeDefault) LiteralLikeData() *LiteralLikeNodeBase { return nil } func (node *NodeDefault) TemplateLiteralLikeData() *TemplateLiteralLikeNodeBase { return nil } func (node *NodeDefault) SubtreeFacts() SubtreeFacts { - return node.data.subtreeFactsWorker(node.data) + return node.AsNode().SubtreeFacts() } -func (node *NodeDefault) subtreeFactsWorker(self nodeData) SubtreeFacts { +func (node *NodeDefault) subtreeFactsWorker(self *Node) SubtreeFacts { // To avoid excessive conditional checks, the default implementation of subtreeFactsWorker directly invokes // computeSubtreeFacts. More complex nodes should implement CompositeNodeBase, which overrides this - // method to cache the result. `self` is passed along to ensure we lookup `computeSubtreeFacts` on the - // correct type, as `CompositeNodeBase` does not, itself, inherit from `Node`. + // method to cache the result. return self.computeSubtreeFacts() } @@ -1240,7 +1028,7 @@ func (node *NodeDefault) computeSubtreeFacts() SubtreeFacts { } func (node *NodeDefault) propagateSubtreeFacts() SubtreeFacts { - return node.data.SubtreeFacts() & ^SubtreeExclusionsNode + return node.AsNode().SubtreeFacts() & ^SubtreeExclusionsNode } // NodeBase @@ -1595,7 +1383,7 @@ func (node *Node) EagerJSDoc(file *SourceFile) []*Node { // CompositeBase -func (node *CompositeBase) subtreeFactsWorker(self nodeData) SubtreeFacts { +func (node *CompositeBase) subtreeFactsWorker(self *Node) SubtreeFacts { // computeSubtreeFacts() is expected to be idempotent, so races will only impact time, not correctness. facts := SubtreeFacts(node.facts.Load()) if facts&SubtreeFactsComputed == 0 { @@ -2544,7 +2332,7 @@ func (f *NodeFactory) NewSourceFile(opts SourceFileParseOptions, text string, st data.text = text data.Statements = statements data.EndOfFileToken = endOfFileToken - return f.newNode(KindSourceFile, data) + return f.newNode(KindSourceFile, data.AsNode()) } func (node *SourceFile) ParseOptions() SourceFileParseOptions { diff --git a/internal/ast/ast_generated.go b/internal/ast/ast_generated.go index 08bb3fdae0a..276f1e91253 100644 --- a/internal/ast/ast_generated.go +++ b/internal/ast/ast_generated.go @@ -4,6 +4,7 @@ package ast import ( "sync/atomic" + "unsafe" "github.com/microsoft/typescript-go/internal/core" ) @@ -598,8 +599,50 @@ type Token struct { } func (f *NodeFactory) NewToken(kind TokenSyntaxKind) *Node { - data := f.tokenArena.New() - return f.newNode(kind, data) + switch kind { + case KindNumericLiteral: + data := f.numericLiteralArena.New() + return f.newNode(kind, data.AsNode()) + case KindBigIntLiteral: + data := &BigIntLiteral{} + return f.newNode(kind, data.AsNode()) + case KindStringLiteral: + data := f.stringLiteralArena.New() + return f.newNode(kind, data.AsNode()) + case KindJsxText: + data := &JsxText{} + return f.newNode(kind, data.AsNode()) + case KindRegularExpressionLiteral: + data := &RegularExpressionLiteral{} + return f.newNode(kind, data.AsNode()) + case KindNoSubstitutionTemplateLiteral: + data := &NoSubstitutionTemplateLiteral{} + return f.newNode(kind, data.AsNode()) + case KindTemplateHead: + data := &TemplateHead{} + return f.newNode(kind, data.AsNode()) + case KindTemplateMiddle: + data := &TemplateMiddle{} + return f.newNode(kind, data.AsNode()) + case KindTemplateTail: + data := &TemplateTail{} + return f.newNode(kind, data.AsNode()) + case KindIdentifier: + data := f.identifierArena.New() + return f.newNode(kind, data.AsNode()) + case KindPrivateIdentifier: + data := &PrivateIdentifier{} + return f.newNode(kind, data.AsNode()) + case KindFalseKeyword, KindImportKeyword, KindNullKeyword, KindSuperKeyword, KindThisKeyword, KindTrueKeyword: + data := f.keywordExpressionArena.New() + return f.newNode(kind, data.AsNode()) + case KindVoidKeyword, KindAnyKeyword, KindBooleanKeyword, KindIntrinsicKeyword, KindNeverKeyword, KindNumberKeyword, KindObjectKeyword, KindStringKeyword, KindSymbolKeyword, KindUndefinedKeyword, KindUnknownKeyword, KindBigIntKeyword: + data := f.keywordTypeNodeArena.New() + return f.newNode(kind, data.AsNode()) + default: + data := f.tokenArena.New() + return f.newNode(kind, data.AsNode()) + } } func (node *Token) Clone(f NodeFactoryCoercible) *Node { @@ -628,7 +671,7 @@ func (f *NodeFactory) NewIdentifier(text string) *Node { data := f.identifierArena.New() data.Text = text f.textCount++ - return f.newNode(KindIdentifier, data) + return f.newNode(KindIdentifier, data.AsNode()) } func (node *Identifier) Clone(f NodeFactoryCoercible) *Node { @@ -652,7 +695,7 @@ func (f *NodeFactory) NewPrivateIdentifier(text string) *Node { data := &PrivateIdentifier{} data.Text = text f.textCount++ - return f.newNode(KindPrivateIdentifier, data) + return f.newNode(KindPrivateIdentifier, data.AsNode()) } func (node *PrivateIdentifier) Clone(f NodeFactoryCoercible) *Node { @@ -679,7 +722,7 @@ func (f *NodeFactory) NewQualifiedName(left *EntityName, right *IdentifierNode) data := &QualifiedName{} data.Left = left data.Right = right - return f.newNode(KindQualifiedName, data) + return f.newNode(KindQualifiedName, data.AsNode()) } func (f *NodeFactory) UpdateQualifiedName(node *QualifiedName, left *EntityName, right *IdentifierNode) *Node { @@ -723,7 +766,7 @@ type ComputedPropertyName struct { func (f *NodeFactory) NewComputedPropertyName(expression *Expression) *Node { data := &ComputedPropertyName{} data.Expression = expression - return f.newNode(KindComputedPropertyName, data) + return f.newNode(KindComputedPropertyName, data.AsNode()) } func (f *NodeFactory) UpdateComputedPropertyName(node *ComputedPropertyName, expression *Expression) *Node { @@ -766,7 +809,7 @@ type Decorator struct { func (f *NodeFactory) NewDecorator(expression *LeftHandSideExpression) *Node { data := &Decorator{} data.Expression = expression - return f.newNode(KindDecorator, data) + return f.newNode(KindDecorator, data.AsNode()) } func (f *NodeFactory) UpdateDecorator(node *Decorator, expression *LeftHandSideExpression) *Node { @@ -802,7 +845,7 @@ type EmptyStatement struct { func (f *NodeFactory) NewEmptyStatement() *Node { data := &EmptyStatement{} - return f.newNode(KindEmptyStatement, data) + return f.newNode(KindEmptyStatement, data.AsNode()) } func (node *EmptyStatement) Clone(f NodeFactoryCoercible) *Node { @@ -830,7 +873,7 @@ func (f *NodeFactory) NewIfStatement(expression *Expression, thenStatement *Stat data.Expression = expression data.ThenStatement = thenStatement data.ElseStatement = elseStatement - return f.newNode(KindIfStatement, data) + return f.newNode(KindIfStatement, data.AsNode()) } func (f *NodeFactory) UpdateIfStatement(node *IfStatement, expression *Expression, thenStatement *Statement, elseStatement *Statement) *Node { @@ -876,7 +919,7 @@ func (f *NodeFactory) NewDoStatement(statement *Statement, expression *Expressio data := &DoStatement{} data.Statement = statement data.Expression = expression - return f.newNode(KindDoStatement, data) + return f.newNode(KindDoStatement, data.AsNode()) } func (f *NodeFactory) UpdateDoStatement(node *DoStatement, statement *Statement, expression *Expression) *Node { @@ -921,7 +964,7 @@ func (f *NodeFactory) NewWhileStatement(expression *Expression, statement *State data := &WhileStatement{} data.Expression = expression data.Statement = statement - return f.newNode(KindWhileStatement, data) + return f.newNode(KindWhileStatement, data.AsNode()) } func (f *NodeFactory) UpdateWhileStatement(node *WhileStatement, expression *Expression, statement *Statement) *Node { @@ -971,7 +1014,7 @@ func (f *NodeFactory) NewForStatement(initializer *ForInitializer, condition *Ex data.Condition = condition data.Incrementor = incrementor data.Statement = statement - return f.newNode(KindForStatement, data) + return f.newNode(KindForStatement, data.AsNode()) } func (f *NodeFactory) UpdateForStatement(node *ForStatement, initializer *ForInitializer, condition *Expression, incrementor *Expression, statement *Statement) *Node { @@ -1027,7 +1070,7 @@ func (f *NodeFactory) NewForInOrOfStatement(kind Kind, awaitModifier *AwaitKeywo data.Initializer = initializer data.Expression = expression data.Statement = statement - return f.newNode(kind, data) + return f.newNode(kind, data.AsNode()) } func (f *NodeFactory) UpdateForInOrOfStatement(node *ForInOrOfStatement, awaitModifier *AwaitKeyword, initializer *ForInitializer, expression *Expression, statement *Statement) *Node { @@ -1072,7 +1115,7 @@ type BreakStatement struct { func (f *NodeFactory) NewBreakStatement(label *IdentifierNode) *Node { data := &BreakStatement{} data.Label = label - return f.newNode(KindBreakStatement, data) + return f.newNode(KindBreakStatement, data.AsNode()) } func (f *NodeFactory) UpdateBreakStatement(node *BreakStatement, label *IdentifierNode) *Node { @@ -1110,7 +1153,7 @@ type ContinueStatement struct { func (f *NodeFactory) NewContinueStatement(label *IdentifierNode) *Node { data := &ContinueStatement{} data.Label = label - return f.newNode(KindContinueStatement, data) + return f.newNode(KindContinueStatement, data.AsNode()) } func (f *NodeFactory) UpdateContinueStatement(node *ContinueStatement, label *IdentifierNode) *Node { @@ -1149,7 +1192,7 @@ type ReturnStatement struct { func (f *NodeFactory) NewReturnStatement(expression *Expression) *Node { data := f.returnStatementArena.New() data.Expression = expression - return f.newNode(KindReturnStatement, data) + return f.newNode(KindReturnStatement, data.AsNode()) } func (f *NodeFactory) UpdateReturnStatement(node *ReturnStatement, expression *Expression) *Node { @@ -1190,7 +1233,7 @@ func (f *NodeFactory) NewWithStatement(expression *Expression, statement *Statem data := &WithStatement{} data.Expression = expression data.Statement = statement - return f.newNode(KindWithStatement, data) + return f.newNode(KindWithStatement, data.AsNode()) } func (f *NodeFactory) UpdateWithStatement(node *WithStatement, expression *Expression, statement *Statement) *Node { @@ -1236,7 +1279,7 @@ func (f *NodeFactory) NewSwitchStatement(expression *Expression, caseBlock *Case data := &SwitchStatement{} data.Expression = expression data.CaseBlock = caseBlock - return f.newNode(KindSwitchStatement, data) + return f.newNode(KindSwitchStatement, data.AsNode()) } func (f *NodeFactory) UpdateSwitchStatement(node *SwitchStatement, expression *Expression, caseBlock *CaseBlockNode) *Node { @@ -1281,7 +1324,7 @@ type CaseBlock struct { func (f *NodeFactory) NewCaseBlock(clauses *CaseClausesList) *Node { data := &CaseBlock{} data.Clauses = clauses - return f.newNode(KindCaseBlock, data) + return f.newNode(KindCaseBlock, data.AsNode()) } func (f *NodeFactory) UpdateCaseBlock(node *CaseBlock, clauses *CaseClausesList) *Node { @@ -1327,7 +1370,7 @@ func (f *NodeFactory) NewCaseOrDefaultClause(kind Kind, expression *Expression, data := &CaseOrDefaultClause{} data.Expression = expression data.Statements = statements - return f.newNode(kind, data) + return f.newNode(kind, data.AsNode()) } func (f *NodeFactory) UpdateCaseOrDefaultClause(node *CaseOrDefaultClause, expression *Expression, statements *StatementList) *Node { @@ -1375,7 +1418,7 @@ type ThrowStatement struct { func (f *NodeFactory) NewThrowStatement(expression *Expression) *Node { data := &ThrowStatement{} data.Expression = expression - return f.newNode(KindThrowStatement, data) + return f.newNode(KindThrowStatement, data.AsNode()) } func (f *NodeFactory) UpdateThrowStatement(node *ThrowStatement, expression *Expression) *Node { @@ -1422,7 +1465,7 @@ func (f *NodeFactory) NewTryStatement(tryBlock *BlockNode, catchClause *CatchCla data.TryBlock = tryBlock data.CatchClause = catchClause data.FinallyBlock = finallyBlock - return f.newNode(KindTryStatement, data) + return f.newNode(KindTryStatement, data.AsNode()) } func (f *NodeFactory) UpdateTryStatement(node *TryStatement, tryBlock *BlockNode, catchClause *CatchClauseNode, finallyBlock *BlockNode) *Node { @@ -1470,7 +1513,7 @@ func (f *NodeFactory) NewCatchClause(variableDeclaration *VariableDeclarationNod data := &CatchClause{} data.VariableDeclaration = variableDeclaration data.Block = block - return f.newNode(KindCatchClause, data) + return f.newNode(KindCatchClause, data.AsNode()) } func (f *NodeFactory) UpdateCatchClause(node *CatchClause, variableDeclaration *VariableDeclarationNode, block *BlockNode) *Node { @@ -1506,7 +1549,7 @@ type DebuggerStatement struct { func (f *NodeFactory) NewDebuggerStatement() *Node { data := &DebuggerStatement{} - return f.newNode(KindDebuggerStatement, data) + return f.newNode(KindDebuggerStatement, data.AsNode()) } func (node *DebuggerStatement) Clone(f NodeFactoryCoercible) *Node { @@ -1531,7 +1574,7 @@ func (f *NodeFactory) NewLabeledStatement(label *IdentifierNode, statement *Stat data := &LabeledStatement{} data.Label = label data.Statement = statement - return f.newNode(KindLabeledStatement, data) + return f.newNode(KindLabeledStatement, data.AsNode()) } func (f *NodeFactory) UpdateLabeledStatement(node *LabeledStatement, label *IdentifierNode, statement *Statement) *Node { @@ -1574,7 +1617,7 @@ type ExpressionStatement struct { func (f *NodeFactory) NewExpressionStatement(expression *Expression) *Node { data := f.expressionStatementArena.New() data.Expression = expression - return f.newNode(KindExpressionStatement, data) + return f.newNode(KindExpressionStatement, data.AsNode()) } func (f *NodeFactory) UpdateExpressionStatement(node *ExpressionStatement, expression *Expression) *Node { @@ -1620,7 +1663,7 @@ func (f *NodeFactory) NewBlock(statements *StatementList, multiLine bool) *Node data := f.blockArena.New() data.Statements = statements data.MultiLine = multiLine - return f.newNode(KindBlock, data) + return f.newNode(KindBlock, data.AsNode()) } func (f *NodeFactory) UpdateBlock(node *Block, statements *StatementList, multiLine bool) *Node { @@ -1665,7 +1708,7 @@ func (f *NodeFactory) NewVariableStatement(modifiers *ModifierList, declarationL data := f.variableStatementArena.New() data.modifiers = modifiers data.DeclarationList = declarationList - return f.newNode(KindVariableStatement, data) + return f.newNode(KindVariableStatement, data.AsNode()) } func (f *NodeFactory) UpdateVariableStatement(node *VariableStatement, modifiers *ModifierList, declarationList *VariableDeclarationListNode) *Node { @@ -1712,7 +1755,7 @@ func (f *NodeFactory) NewVariableDeclaration(name *BindingName, exclamationToken data.ExclamationToken = exclamationToken data.Type = typeNode data.Initializer = initializer - return f.newNode(KindVariableDeclaration, data) + return f.newNode(KindVariableDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateVariableDeclaration(node *VariableDeclaration, name *BindingName, exclamationToken *ExclamationToken, typeNode *TypeNode, initializer *Expression) *Node { @@ -1758,7 +1801,7 @@ type VariableDeclarationList struct { func (f *NodeFactory) NewVariableDeclarationList(declarations *VariableDeclarationNodeList, flags NodeFlags) *Node { data := f.variableDeclarationListArena.New() data.Declarations = declarations - node := f.newNode(KindVariableDeclarationList, data) + node := f.newNode(KindVariableDeclarationList, data.AsNode()) node.Flags = flags return node } @@ -1799,7 +1842,7 @@ type BindingPattern struct { func (f *NodeFactory) NewBindingPattern(kind Kind, elements *BindingElementList) *Node { data := &BindingPattern{} data.Elements = elements - return f.newNode(kind, data) + return f.newNode(kind, data.AsNode()) } func (f *NodeFactory) UpdateBindingPattern(node *BindingPattern, elements *BindingElementList) *Node { @@ -1853,7 +1896,7 @@ func (f *NodeFactory) NewParameterDeclaration(modifiers *ModifierList, dotDotDot data.QuestionToken = questionToken data.Type = typeNode data.Initializer = initializer - return f.newNode(KindParameter, data) + return f.newNode(KindParameter, data.AsNode()) } func (f *NodeFactory) UpdateParameterDeclaration(node *ParameterDeclaration, modifiers *ModifierList, dotDotDotToken *DotDotDotToken, name *BindingName, questionToken *QuestionToken, typeNode *TypeNode, initializer *Expression) *Node { @@ -1910,7 +1953,7 @@ func (f *NodeFactory) NewBindingElement(dotDotDotToken *DotDotDotToken, property data.PropertyName = propertyName data.name = name data.Initializer = initializer - return f.newNode(KindBindingElement, data) + return f.newNode(KindBindingElement, data.AsNode()) } func (f *NodeFactory) UpdateBindingElement(node *BindingElement, dotDotDotToken *DotDotDotToken, propertyName *PropertyName, name *BindingName, initializer *Expression) *Node { @@ -1956,7 +1999,7 @@ type MissingDeclaration struct { func (f *NodeFactory) NewMissingDeclaration(modifiers *ModifierList) *Node { data := &MissingDeclaration{} data.modifiers = modifiers - return f.newNode(KindMissingDeclaration, data) + return f.newNode(KindMissingDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateMissingDeclaration(node *MissingDeclaration, modifiers *ModifierList) *Node { @@ -2007,7 +2050,7 @@ func (f *NodeFactory) NewFunctionDeclaration(modifiers *ModifierList, asteriskTo data.Type = typeNode data.FullSignature = fullSignature data.Body = body - return f.newNode(KindFunctionDeclaration, data) + return f.newNode(KindFunctionDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateFunctionDeclaration(node *FunctionDeclaration, modifiers *ModifierList, asteriskToken *AsteriskToken, name *IdentifierNode, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode, fullSignature *TypeNode, body *FunctionBody) *Node { @@ -2061,7 +2104,7 @@ func (f *NodeFactory) NewClassDeclaration(modifiers *ModifierList, name *Identif data.TypeParameters = typeParameters data.HeritageClauses = heritageClauses data.Members = members - return f.newNode(KindClassDeclaration, data) + return f.newNode(KindClassDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateClassDeclaration(node *ClassDeclaration, modifiers *ModifierList, name *IdentifierNode, typeParameters *TypeParameterList, heritageClauses *HeritageClauseList, members *ClassElementList) *Node { @@ -2112,7 +2155,7 @@ func (f *NodeFactory) NewClassExpression(modifiers *ModifierList, name *Identifi data.TypeParameters = typeParameters data.HeritageClauses = heritageClauses data.Members = members - return f.newNode(KindClassExpression, data) + return f.newNode(KindClassExpression, data.AsNode()) } func (f *NodeFactory) UpdateClassExpression(node *ClassExpression, modifiers *ModifierList, name *IdentifierNode, typeParameters *TypeParameterList, heritageClauses *HeritageClauseList, members *ClassElementList) *Node { @@ -2161,7 +2204,7 @@ func (f *NodeFactory) NewHeritageClause(token Kind, types *HeritageClauseElement data := f.heritageClauseArena.New() data.Token = token data.Types = types - return f.newNode(KindHeritageClause, data) + return f.newNode(KindHeritageClause, data.AsNode()) } func (f *NodeFactory) UpdateHeritageClause(node *HeritageClause, token Kind, types *HeritageClauseElementList) *Node { @@ -2210,7 +2253,7 @@ func (f *NodeFactory) NewInterfaceDeclaration(modifiers *ModifierList, name *Ide data.TypeParameters = typeParameters data.HeritageClauses = heritageClauses data.Members = members - return f.newNode(KindInterfaceDeclaration, data) + return f.newNode(KindInterfaceDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateInterfaceDeclaration(node *InterfaceDeclaration, modifiers *ModifierList, name *IdentifierNode, typeParameters *TypeParameterList, heritageClauses *HeritageClauseList, members *TypeElementList) *Node { @@ -2266,7 +2309,7 @@ func (f *NodeFactory) NewTypeAliasDeclaration(modifiers *ModifierList, name *Ide data.name = name data.TypeParameters = typeParameters data.Type = typeNode - return f.newNode(KindTypeAliasDeclaration, data) + return f.newNode(KindTypeAliasDeclaration, data.AsNode()) } func (f *NodeFactory) NewJSTypeAliasDeclaration(modifiers *ModifierList, name *IdentifierNode, typeParameters *TypeParameterList, typeNode *TypeNode) *Node { @@ -2275,7 +2318,7 @@ func (f *NodeFactory) NewJSTypeAliasDeclaration(modifiers *ModifierList, name *I data.name = name data.TypeParameters = typeParameters data.Type = typeNode - return f.newNode(KindJSTypeAliasDeclaration, data) + return f.newNode(KindJSTypeAliasDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateTypeAliasDeclaration(node *TypeAliasDeclaration, modifiers *ModifierList, name *IdentifierNode, typeParameters *TypeParameterList, typeNode *TypeNode) *Node { @@ -2342,7 +2385,7 @@ func (f *NodeFactory) NewEnumMember(name *PropertyName, initializer *Expression) data := &EnumMember{} data.name = name data.Initializer = initializer - return f.newNode(KindEnumMember, data) + return f.newNode(KindEnumMember, data.AsNode()) } func (f *NodeFactory) UpdateEnumMember(node *EnumMember, name *PropertyName, initializer *Expression) *Node { @@ -2391,7 +2434,7 @@ func (f *NodeFactory) NewEnumDeclaration(modifiers *ModifierList, name *Identifi data.modifiers = modifiers data.name = name data.Members = members - return f.newNode(KindEnumDeclaration, data) + return f.newNode(KindEnumDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateEnumDeclaration(node *EnumDeclaration, modifiers *ModifierList, name *IdentifierNode, members *EnumMemberList) *Node { @@ -2434,7 +2477,7 @@ type ModuleBlock struct { func (f *NodeFactory) NewModuleBlock(statements *StatementList) *Node { data := &ModuleBlock{} data.Statements = statements - return f.newNode(KindModuleBlock, data) + return f.newNode(KindModuleBlock, data.AsNode()) } func (f *NodeFactory) UpdateModuleBlock(node *ModuleBlock, statements *StatementList) *Node { @@ -2474,7 +2517,7 @@ type NotEmittedStatement struct { func (f *NodeFactory) NewNotEmittedStatement() *Node { data := &NotEmittedStatement{} - return f.newNode(KindNotEmittedStatement, data) + return f.newNode(KindNotEmittedStatement, data.AsNode()) } func (node *NotEmittedStatement) Clone(f NodeFactoryCoercible) *Node { @@ -2496,7 +2539,7 @@ type NotEmittedTypeElement struct { func (f *NodeFactory) NewNotEmittedTypeElement() *Node { data := &NotEmittedTypeElement{} - return f.newNode(KindNotEmittedTypeElement, data) + return f.newNode(KindNotEmittedTypeElement, data.AsNode()) } func (node *NotEmittedTypeElement) Clone(f NodeFactoryCoercible) *Node { @@ -2527,7 +2570,7 @@ func (f *NodeFactory) NewImportDeclaration(modifiers *ModifierList, importClause data.ImportClause = importClause data.ModuleSpecifier = moduleSpecifier data.Attributes = attributes - return f.newNode(KindImportDeclaration, data) + return f.newNode(KindImportDeclaration, data.AsNode()) } func (f *NodeFactory) NewJSImportDeclaration(modifiers *ModifierList, importClause *ImportClauseNode, moduleSpecifier *Expression, attributes *ImportAttributesNode) *Node { @@ -2536,7 +2579,7 @@ func (f *NodeFactory) NewJSImportDeclaration(modifiers *ModifierList, importClau data.ImportClause = importClause data.ModuleSpecifier = moduleSpecifier data.Attributes = attributes - return f.newNode(KindJSImportDeclaration, data) + return f.newNode(KindJSImportDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateImportDeclaration(node *ImportDeclaration, modifiers *ModifierList, importClause *ImportClauseNode, moduleSpecifier *Expression, attributes *ImportAttributesNode) *Node { @@ -2602,7 +2645,7 @@ type ExternalModuleReference struct { func (f *NodeFactory) NewExternalModuleReference(expression *Expression) *Node { data := &ExternalModuleReference{} data.Expression = expression - return f.newNode(KindExternalModuleReference, data) + return f.newNode(KindExternalModuleReference, data.AsNode()) } func (f *NodeFactory) UpdateExternalModuleReference(node *ExternalModuleReference, expression *Expression) *Node { @@ -2646,7 +2689,7 @@ type NamespaceImport struct { func (f *NodeFactory) NewNamespaceImport(name *IdentifierNode) *Node { data := &NamespaceImport{} data.name = name - return f.newNode(KindNamespaceImport, data) + return f.newNode(KindNamespaceImport, data.AsNode()) } func (f *NodeFactory) UpdateNamespaceImport(node *NamespaceImport, name *IdentifierNode) *Node { @@ -2693,7 +2736,7 @@ type NamedImports struct { func (f *NodeFactory) NewNamedImports(elements *ImportSpecifierList) *Node { data := &NamedImports{} data.Elements = elements - return f.newNode(KindNamedImports, data) + return f.newNode(KindNamedImports, data.AsNode()) } func (f *NodeFactory) UpdateNamedImports(node *NamedImports, elements *ImportSpecifierList) *Node { @@ -2743,7 +2786,7 @@ func (f *NodeFactory) NewExportAssignment(modifiers *ModifierList, isExportEqual data.IsExportEquals = isExportEquals data.Type = typeNode data.Expression = expression - return f.newNode(KindExportAssignment, data) + return f.newNode(KindExportAssignment, data.AsNode()) } func (f *NodeFactory) UpdateExportAssignment(node *ExportAssignment, modifiers *ModifierList, isExportEquals bool, typeNode *TypeNode, expression *Expression) *Node { @@ -2785,7 +2828,7 @@ func (f *NodeFactory) NewNamespaceExportDeclaration(modifiers *ModifierList, nam data := &NamespaceExportDeclaration{} data.modifiers = modifiers data.name = name - return f.newNode(KindNamespaceExportDeclaration, data) + return f.newNode(KindNamespaceExportDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateNamespaceExportDeclaration(node *NamespaceExportDeclaration, modifiers *ModifierList, name *IdentifierNode) *Node { @@ -2828,7 +2871,7 @@ type NamespaceExport struct { func (f *NodeFactory) NewNamespaceExport(name *ModuleExportName) *Node { data := &NamespaceExport{} data.name = name - return f.newNode(KindNamespaceExport, data) + return f.newNode(KindNamespaceExport, data.AsNode()) } func (f *NodeFactory) UpdateNamespaceExport(node *NamespaceExport, name *ModuleExportName) *Node { @@ -2875,7 +2918,7 @@ type NamedExports struct { func (f *NodeFactory) NewNamedExports(elements *ExportSpecifierList) *Node { data := &NamedExports{} data.Elements = elements - return f.newNode(KindNamedExports, data) + return f.newNode(KindNamedExports, data.AsNode()) } func (f *NodeFactory) UpdateNamedExports(node *NamedExports, elements *ExportSpecifierList) *Node { @@ -2924,7 +2967,7 @@ func (f *NodeFactory) NewExportSpecifier(isTypeOnly bool, propertyName *ModuleEx data.IsTypeOnly = isTypeOnly data.PropertyName = propertyName data.name = name - return f.newNode(KindExportSpecifier, data) + return f.newNode(KindExportSpecifier, data.AsNode()) } func (f *NodeFactory) UpdateExportSpecifier(node *ExportSpecifier, isTypeOnly bool, propertyName *ModuleExportName, name *ModuleExportName) *Node { @@ -2971,7 +3014,7 @@ func (f *NodeFactory) NewCallSignatureDeclaration(typeParameters *TypeParameterL data.TypeParameters = typeParameters data.Parameters = parameters data.Type = typeNode - return f.newNode(KindCallSignature, data) + return f.newNode(KindCallSignature, data.AsNode()) } func (f *NodeFactory) UpdateCallSignatureDeclaration(node *CallSignatureDeclaration, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode) *Node { @@ -3014,7 +3057,7 @@ func (f *NodeFactory) NewConstructSignatureDeclaration(typeParameters *TypeParam data.TypeParameters = typeParameters data.Parameters = parameters data.Type = typeNode - return f.newNode(KindConstructSignature, data) + return f.newNode(KindConstructSignature, data.AsNode()) } func (f *NodeFactory) UpdateConstructSignatureDeclaration(node *ConstructSignatureDeclaration, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode) *Node { @@ -3062,7 +3105,7 @@ func (f *NodeFactory) NewConstructorDeclaration(modifiers *ModifierList, typePar data.Type = typeNode data.FullSignature = fullSignature data.Body = body - return f.newNode(KindConstructor, data) + return f.newNode(KindConstructor, data.AsNode()) } func (f *NodeFactory) UpdateConstructorDeclaration(node *ConstructorDeclaration, modifiers *ModifierList, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode, fullSignature *TypeNode, body *FunctionBody) *Node { @@ -3110,7 +3153,7 @@ func (f *NodeFactory) NewGetAccessorDeclaration(modifiers *ModifierList, name *P data.Type = typeNode data.FullSignature = fullSignature data.Body = body - return f.newNode(KindGetAccessor, data) + return f.newNode(KindGetAccessor, data.AsNode()) } func (f *NodeFactory) UpdateGetAccessorDeclaration(node *GetAccessorDeclaration, modifiers *ModifierList, name *PropertyName, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode, fullSignature *TypeNode, body *FunctionBody) *Node { @@ -3163,7 +3206,7 @@ func (f *NodeFactory) NewSetAccessorDeclaration(modifiers *ModifierList, name *P data.Type = typeNode data.FullSignature = fullSignature data.Body = body - return f.newNode(KindSetAccessor, data) + return f.newNode(KindSetAccessor, data.AsNode()) } func (f *NodeFactory) UpdateSetAccessorDeclaration(node *SetAccessorDeclaration, modifiers *ModifierList, name *PropertyName, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode, fullSignature *TypeNode, body *FunctionBody) *Node { @@ -3218,7 +3261,7 @@ func (f *NodeFactory) NewIndexSignatureDeclaration(modifiers *ModifierList, para data.modifiers = modifiers data.Parameters = parameters data.Type = typeNode - return f.newNode(KindIndexSignature, data) + return f.newNode(KindIndexSignature, data.AsNode()) } func (f *NodeFactory) UpdateIndexSignatureDeclaration(node *IndexSignatureDeclaration, modifiers *ModifierList, parameters *ParameterList, typeNode *TypeNode) *Node { @@ -3265,7 +3308,7 @@ func (f *NodeFactory) NewMethodSignatureDeclaration(modifiers *ModifierList, nam data.TypeParameters = typeParameters data.Parameters = parameters data.Type = typeNode - return f.newNode(KindMethodSignature, data) + return f.newNode(KindMethodSignature, data.AsNode()) } func (f *NodeFactory) UpdateMethodSignatureDeclaration(node *MethodSignatureDeclaration, modifiers *ModifierList, name *PropertyName, postfixToken *TokenNode, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode) *Node { @@ -3326,7 +3369,7 @@ func (f *NodeFactory) NewMethodDeclaration(modifiers *ModifierList, asteriskToke data.Type = typeNode data.FullSignature = fullSignature data.Body = body - return f.newNode(KindMethodDeclaration, data) + return f.newNode(KindMethodDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateMethodDeclaration(node *MethodDeclaration, modifiers *ModifierList, asteriskToken *AsteriskToken, name *PropertyName, postfixToken *TokenNode, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode, fullSignature *TypeNode, body *FunctionBody) *Node { @@ -3385,7 +3428,7 @@ func (f *NodeFactory) NewPropertySignatureDeclaration(modifiers *ModifierList, n data.PostfixToken = postfixToken data.Type = typeNode data.Initializer = initializer - return f.newNode(KindPropertySignature, data) + return f.newNode(KindPropertySignature, data.AsNode()) } func (f *NodeFactory) UpdatePropertySignatureDeclaration(node *PropertySignatureDeclaration, modifiers *ModifierList, name *PropertyName, postfixToken *TokenNode, typeNode *TypeNode, initializer *Expression) *Node { @@ -3440,7 +3483,7 @@ func (f *NodeFactory) NewPropertyDeclaration(modifiers *ModifierList, name *Prop data.PostfixToken = postfixToken data.Type = typeNode data.Initializer = initializer - return f.newNode(KindPropertyDeclaration, data) + return f.newNode(KindPropertyDeclaration, data.AsNode()) } func (f *NodeFactory) UpdatePropertyDeclaration(node *PropertyDeclaration, modifiers *ModifierList, name *PropertyName, postfixToken *TokenNode, typeNode *TypeNode, initializer *Expression) *Node { @@ -3486,7 +3529,7 @@ type SemicolonClassElement struct { func (f *NodeFactory) NewSemicolonClassElement() *Node { data := &SemicolonClassElement{} - return f.newNode(KindSemicolonClassElement, data) + return f.newNode(KindSemicolonClassElement, data.AsNode()) } func (node *SemicolonClassElement) Clone(f NodeFactoryCoercible) *Node { @@ -3516,7 +3559,7 @@ func (f *NodeFactory) NewClassStaticBlockDeclaration(modifiers *ModifierList, bo data := &ClassStaticBlockDeclaration{} data.modifiers = modifiers data.Body = body - return f.newNode(KindClassStaticBlockDeclaration, data) + return f.newNode(KindClassStaticBlockDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateClassStaticBlockDeclaration(node *ClassStaticBlockDeclaration, modifiers *ModifierList, body *BlockNode) *Node { @@ -3552,7 +3595,7 @@ type OmittedExpression struct { func (f *NodeFactory) NewOmittedExpression() *Node { data := &OmittedExpression{} - return f.newNode(KindOmittedExpression, data) + return f.newNode(KindOmittedExpression, data.AsNode()) } func (node *OmittedExpression) Clone(f NodeFactoryCoercible) *Node { @@ -3574,7 +3617,7 @@ type KeywordExpression struct { func (f *NodeFactory) NewKeywordExpression(kind KeywordExpressionSyntaxKind) *Node { data := f.keywordExpressionArena.New() - return f.newNode(kind, data) + return f.newNode(kind, data.AsNode()) } func (node *KeywordExpression) Clone(f NodeFactoryCoercible) *Node { @@ -3602,7 +3645,7 @@ func (f *NodeFactory) NewStringLiteral(text string, tokenFlags TokenFlags) *Node data.Text = text data.TokenFlags = tokenFlags & TokenFlagsStringLiteralFlags f.textCount++ - return f.newNode(KindStringLiteral, data) + return f.newNode(KindStringLiteral, data.AsNode()) } func (node *StringLiteral) Clone(f NodeFactoryCoercible) *Node { @@ -3626,7 +3669,7 @@ func (f *NodeFactory) NewNumericLiteral(text string, tokenFlags TokenFlags) *Nod data.Text = text data.TokenFlags = tokenFlags & TokenFlagsNumericLiteralFlags f.textCount++ - return f.newNode(KindNumericLiteral, data) + return f.newNode(KindNumericLiteral, data.AsNode()) } func (node *NumericLiteral) Clone(f NodeFactoryCoercible) *Node { @@ -3650,7 +3693,7 @@ func (f *NodeFactory) NewBigIntLiteral(text string, tokenFlags TokenFlags) *Node data.Text = text data.TokenFlags = tokenFlags & TokenFlagsNumericLiteralFlags f.textCount++ - return f.newNode(KindBigIntLiteral, data) + return f.newNode(KindBigIntLiteral, data.AsNode()) } func (node *BigIntLiteral) Clone(f NodeFactoryCoercible) *Node { @@ -3674,7 +3717,7 @@ func (f *NodeFactory) NewRegularExpressionLiteral(text string, tokenFlags TokenF data.Text = text data.TokenFlags = tokenFlags & TokenFlagsRegularExpressionLiteralFlags f.textCount++ - return f.newNode(KindRegularExpressionLiteral, data) + return f.newNode(KindRegularExpressionLiteral, data.AsNode()) } func (node *RegularExpressionLiteral) Clone(f NodeFactoryCoercible) *Node { @@ -3700,7 +3743,7 @@ func (f *NodeFactory) NewNoSubstitutionTemplateLiteral(text string, templateFlag data.Text = text data.TemplateFlags = templateFlags & TokenFlagsTemplateLiteralLikeFlags f.textCount++ - return f.newNode(KindNoSubstitutionTemplateLiteral, data) + return f.newNode(KindNoSubstitutionTemplateLiteral, data.AsNode()) } func (node *NoSubstitutionTemplateLiteral) Clone(f NodeFactoryCoercible) *Node { @@ -3733,7 +3776,7 @@ func (f *NodeFactory) NewBinaryExpression(modifiers *ModifierList, left *Express data.Type = typeNode data.OperatorToken = operatorToken data.Right = right - return f.newNode(KindBinaryExpression, data) + return f.newNode(KindBinaryExpression, data.AsNode()) } func (f *NodeFactory) UpdateBinaryExpression(node *BinaryExpression, modifiers *ModifierList, left *Expression, typeNode *TypeNode, operatorToken *BinaryOperatorToken, right *Expression) *Node { @@ -3777,7 +3820,7 @@ func (f *NodeFactory) NewPrefixUnaryExpression(operator Kind, operand *Expressio data := f.prefixUnaryExpressionArena.New() data.Operator = operator data.Operand = operand - return f.newNode(KindPrefixUnaryExpression, data) + return f.newNode(KindPrefixUnaryExpression, data.AsNode()) } func (f *NodeFactory) UpdatePrefixUnaryExpression(node *PrefixUnaryExpression, operator Kind, operand *Expression) *Node { @@ -3821,7 +3864,7 @@ func (f *NodeFactory) NewPostfixUnaryExpression(operand *Expression, operator Ki data := &PostfixUnaryExpression{} data.Operand = operand data.Operator = operator - return f.newNode(KindPostfixUnaryExpression, data) + return f.newNode(KindPostfixUnaryExpression, data.AsNode()) } func (f *NodeFactory) UpdatePostfixUnaryExpression(node *PostfixUnaryExpression, operand *Expression, operator Kind) *Node { @@ -3865,7 +3908,7 @@ func (f *NodeFactory) NewYieldExpression(asteriskToken *AsteriskToken, expressio data := &YieldExpression{} data.AsteriskToken = asteriskToken data.Expression = expression - return f.newNode(KindYieldExpression, data) + return f.newNode(KindYieldExpression, data.AsNode()) } func (f *NodeFactory) UpdateYieldExpression(node *YieldExpression, asteriskToken *AsteriskToken, expression *Expression) *Node { @@ -3914,7 +3957,7 @@ func (f *NodeFactory) NewArrowFunction(modifiers *ModifierList, typeParameters * data.FullSignature = fullSignature data.EqualsGreaterThanToken = equalsGreaterThanToken data.Body = body - return f.newNode(KindArrowFunction, data) + return f.newNode(KindArrowFunction, data.AsNode()) } func (f *NodeFactory) UpdateArrowFunction(node *ArrowFunction, modifiers *ModifierList, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode, fullSignature *TypeNode, equalsGreaterThanToken *EqualsGreaterThanToken, body *ConciseBody) *Node { @@ -3971,7 +4014,7 @@ func (f *NodeFactory) NewFunctionExpression(modifiers *ModifierList, asteriskTok data.Type = typeNode data.FullSignature = fullSignature data.Body = body - return f.newNode(KindFunctionExpression, data) + return f.newNode(KindFunctionExpression, data.AsNode()) } func (f *NodeFactory) UpdateFunctionExpression(node *FunctionExpression, modifiers *ModifierList, asteriskToken *AsteriskToken, name *IdentifierNode, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode, fullSignature *TypeNode, body *FunctionBody) *Node { @@ -4022,7 +4065,7 @@ func (f *NodeFactory) NewAsExpression(expression *Expression, typeNode *TypeNode data := &AsExpression{} data.Expression = expression data.Type = typeNode - return f.newNode(KindAsExpression, data) + return f.newNode(KindAsExpression, data.AsNode()) } func (f *NodeFactory) UpdateAsExpression(node *AsExpression, expression *Expression, typeNode *TypeNode) *Node { @@ -4062,7 +4105,7 @@ func (f *NodeFactory) NewSatisfiesExpression(expression *Expression, typeNode *T data := &SatisfiesExpression{} data.Expression = expression data.Type = typeNode - return f.newNode(KindSatisfiesExpression, data) + return f.newNode(KindSatisfiesExpression, data.AsNode()) } func (f *NodeFactory) UpdateSatisfiesExpression(node *SatisfiesExpression, expression *Expression, typeNode *TypeNode) *Node { @@ -4109,7 +4152,7 @@ func (f *NodeFactory) NewConditionalExpression(condition *Expression, questionTo data.WhenTrue = whenTrue data.ColonToken = colonToken data.WhenFalse = whenFalse - return f.newNode(KindConditionalExpression, data) + return f.newNode(KindConditionalExpression, data.AsNode()) } func (f *NodeFactory) UpdateConditionalExpression(node *ConditionalExpression, condition *Expression, questionToken *QuestionToken, whenTrue *Expression, colonToken *ColonToken, whenFalse *Expression) *Node { @@ -4165,7 +4208,7 @@ func (f *NodeFactory) NewPropertyAccessExpression(expression *Expression, questi data.Expression = expression data.QuestionDotToken = questionDotToken data.name = name - node := f.newNode(KindPropertyAccessExpression, data) + node := f.newNode(KindPropertyAccessExpression, data.AsNode()) node.Flags |= flags & NodeFlagsOptionalChain return node } @@ -4215,7 +4258,7 @@ func (f *NodeFactory) NewElementAccessExpression(expression *Expression, questio data.Expression = expression data.QuestionDotToken = questionDotToken data.ArgumentExpression = argumentExpression - node := f.newNode(KindElementAccessExpression, data) + node := f.newNode(KindElementAccessExpression, data.AsNode()) node.Flags |= flags & NodeFlagsOptionalChain return node } @@ -4269,7 +4312,7 @@ func (f *NodeFactory) NewCallExpression(expression *Expression, questionDotToken data.QuestionDotToken = questionDotToken data.TypeArguments = typeArguments data.Arguments = arguments - node := f.newNode(KindCallExpression, data) + node := f.newNode(KindCallExpression, data.AsNode()) node.Flags |= flags & NodeFlagsOptionalChain return node } @@ -4317,7 +4360,7 @@ func (f *NodeFactory) NewNewExpression(expression *Expression, typeArguments *Ty data.Expression = expression data.TypeArguments = typeArguments data.Arguments = arguments - return f.newNode(KindNewExpression, data) + return f.newNode(KindNewExpression, data.AsNode()) } func (f *NodeFactory) UpdateNewExpression(node *NewExpression, expression *Expression, typeArguments *TypeList, arguments *ElementList) *Node { @@ -4359,7 +4402,7 @@ func (f *NodeFactory) NewMetaProperty(keywordToken Kind, name *IdentifierNode) * data := &MetaProperty{} data.KeywordToken = keywordToken data.name = name - return f.newNode(KindMetaProperty, data) + return f.newNode(KindMetaProperty, data.AsNode()) } func (f *NodeFactory) UpdateMetaProperty(node *MetaProperty, keywordToken Kind, name *IdentifierNode) *Node { @@ -4401,7 +4444,7 @@ type NonNullExpression struct { func (f *NodeFactory) NewNonNullExpression(expression *Expression, flags NodeFlags) *Node { data := &NonNullExpression{} data.Expression = expression - node := f.newNode(KindNonNullExpression, data) + node := f.newNode(KindNonNullExpression, data.AsNode()) node.Flags |= flags & NodeFlagsOptionalChain return node } @@ -4441,7 +4484,7 @@ type SpreadElement struct { func (f *NodeFactory) NewSpreadElement(expression *Expression) *Node { data := &SpreadElement{} data.Expression = expression - return f.newNode(KindSpreadElement, data) + return f.newNode(KindSpreadElement, data.AsNode()) } func (f *NodeFactory) UpdateSpreadElement(node *SpreadElement, expression *Expression) *Node { @@ -4482,7 +4525,7 @@ func (f *NodeFactory) NewTemplateExpression(head *TemplateHeadNode, templateSpan data := &TemplateExpression{} data.Head = head data.TemplateSpans = templateSpans - return f.newNode(KindTemplateExpression, data) + return f.newNode(KindTemplateExpression, data.AsNode()) } func (f *NodeFactory) UpdateTemplateExpression(node *TemplateExpression, head *TemplateHeadNode, templateSpans *TemplateSpanList) *Node { @@ -4527,7 +4570,7 @@ func (f *NodeFactory) NewTemplateSpan(expression *Expression, literal *TemplateM data := &TemplateSpan{} data.Expression = expression data.Literal = literal - return f.newNode(KindTemplateSpan, data) + return f.newNode(KindTemplateSpan, data.AsNode()) } func (f *NodeFactory) UpdateTemplateSpan(node *TemplateSpan, expression *Expression, literal *TemplateMiddleOrTail) *Node { @@ -4577,7 +4620,7 @@ func (f *NodeFactory) NewTaggedTemplateExpression(tag *Expression, questionDotTo data.QuestionDotToken = questionDotToken data.TypeArguments = typeArguments data.Template = template - node := f.newNode(KindTaggedTemplateExpression, data) + node := f.newNode(KindTaggedTemplateExpression, data.AsNode()) node.Flags |= flags & NodeFlagsOptionalChain return node } @@ -4620,7 +4663,7 @@ type ParenthesizedExpression struct { func (f *NodeFactory) NewParenthesizedExpression(expression *Expression) *Node { data := f.parenthesizedExpressionArena.New() data.Expression = expression - return f.newNode(KindParenthesizedExpression, data) + return f.newNode(KindParenthesizedExpression, data.AsNode()) } func (f *NodeFactory) UpdateParenthesizedExpression(node *ParenthesizedExpression, expression *Expression) *Node { @@ -4665,7 +4708,7 @@ func (f *NodeFactory) NewArrayLiteralExpression(elements *ElementList, multiLine data := &ArrayLiteralExpression{} data.Elements = elements data.MultiLine = multiLine - return f.newNode(KindArrayLiteralExpression, data) + return f.newNode(KindArrayLiteralExpression, data.AsNode()) } func (f *NodeFactory) UpdateArrayLiteralExpression(node *ArrayLiteralExpression, elements *ElementList, multiLine bool) *Node { @@ -4711,7 +4754,7 @@ func (f *NodeFactory) NewObjectLiteralExpression(properties *NodeList, multiLine data := &ObjectLiteralExpression{} data.Properties = properties data.MultiLine = multiLine - return f.newNode(KindObjectLiteralExpression, data) + return f.newNode(KindObjectLiteralExpression, data.AsNode()) } func (f *NodeFactory) UpdateObjectLiteralExpression(node *ObjectLiteralExpression, properties *NodeList, multiLine bool) *Node { @@ -4755,7 +4798,7 @@ type SpreadAssignment struct { func (f *NodeFactory) NewSpreadAssignment(expression *Expression) *Node { data := &SpreadAssignment{} data.Expression = expression - return f.newNode(KindSpreadAssignment, data) + return f.newNode(KindSpreadAssignment, data.AsNode()) } func (f *NodeFactory) UpdateSpreadAssignment(node *SpreadAssignment, expression *Expression) *Node { @@ -4802,7 +4845,7 @@ func (f *NodeFactory) NewPropertyAssignment(modifiers *ModifierList, name *Prope data.PostfixToken = postfixToken data.Type = typeNode data.Initializer = initializer - return f.newNode(KindPropertyAssignment, data) + return f.newNode(KindPropertyAssignment, data.AsNode()) } func (f *NodeFactory) UpdatePropertyAssignment(node *PropertyAssignment, modifiers *ModifierList, name *PropertyName, postfixToken *TokenNode, typeNode *TypeNode, initializer *Expression) *Node { @@ -4859,7 +4902,7 @@ func (f *NodeFactory) NewShorthandPropertyAssignment(modifiers *ModifierList, na data.Type = typeNode data.EqualsToken = equalsToken data.ObjectAssignmentInitializer = objectAssignmentInitializer - return f.newNode(KindShorthandPropertyAssignment, data) + return f.newNode(KindShorthandPropertyAssignment, data.AsNode()) } func (f *NodeFactory) UpdateShorthandPropertyAssignment(node *ShorthandPropertyAssignment, modifiers *ModifierList, name *PropertyName, postfixToken *TokenNode, typeNode *TypeNode, equalsToken *EqualsToken, objectAssignmentInitializer *Expression) *Node { @@ -4906,7 +4949,7 @@ type DeleteExpression struct { func (f *NodeFactory) NewDeleteExpression(expression *Expression) *Node { data := &DeleteExpression{} data.Expression = expression - return f.newNode(KindDeleteExpression, data) + return f.newNode(KindDeleteExpression, data.AsNode()) } func (f *NodeFactory) UpdateDeleteExpression(node *DeleteExpression, expression *Expression) *Node { @@ -4948,7 +4991,7 @@ type TypeOfExpression struct { func (f *NodeFactory) NewTypeOfExpression(expression *Expression) *Node { data := &TypeOfExpression{} data.Expression = expression - return f.newNode(KindTypeOfExpression, data) + return f.newNode(KindTypeOfExpression, data.AsNode()) } func (f *NodeFactory) UpdateTypeOfExpression(node *TypeOfExpression, expression *Expression) *Node { @@ -4990,7 +5033,7 @@ type VoidExpression struct { func (f *NodeFactory) NewVoidExpression(expression *Expression) *Node { data := &VoidExpression{} data.Expression = expression - return f.newNode(KindVoidExpression, data) + return f.newNode(KindVoidExpression, data.AsNode()) } func (f *NodeFactory) UpdateVoidExpression(node *VoidExpression, expression *Expression) *Node { @@ -5032,7 +5075,7 @@ type AwaitExpression struct { func (f *NodeFactory) NewAwaitExpression(expression *Expression) *Node { data := &AwaitExpression{} data.Expression = expression - return f.newNode(KindAwaitExpression, data) + return f.newNode(KindAwaitExpression, data.AsNode()) } func (f *NodeFactory) UpdateAwaitExpression(node *AwaitExpression, expression *Expression) *Node { @@ -5072,7 +5115,7 @@ func (f *NodeFactory) NewTypeAssertion(typeNode *TypeNode, expression *Expressio data := &TypeAssertion{} data.Type = typeNode data.Expression = expression - return f.newNode(KindTypeAssertionExpression, data) + return f.newNode(KindTypeAssertionExpression, data.AsNode()) } func (f *NodeFactory) UpdateTypeAssertion(node *TypeAssertion, typeNode *TypeNode, expression *Expression) *Node { @@ -5108,7 +5151,7 @@ type KeywordTypeNode struct { func (f *NodeFactory) NewKeywordTypeNode(kind KeywordTypeSyntaxKind) *Node { data := f.keywordTypeNodeArena.New() - return f.newNode(kind, data) + return f.newNode(kind, data.AsNode()) } func (node *KeywordTypeNode) Clone(f NodeFactoryCoercible) *Node { @@ -5134,7 +5177,7 @@ type UnionTypeNode struct { func (f *NodeFactory) NewUnionTypeNode(types *TypeList) *Node { data := f.unionTypeNodeArena.New() data.Types = types - return f.newNode(KindUnionType, data) + return f.newNode(KindUnionType, data.AsNode()) } func (f *NodeFactory) UpdateUnionTypeNode(node *UnionTypeNode, types *TypeList) *Node { @@ -5171,7 +5214,7 @@ type IntersectionTypeNode struct { func (f *NodeFactory) NewIntersectionTypeNode(types *TypeList) *Node { data := f.intersectionTypeNodeArena.New() data.Types = types - return f.newNode(KindIntersectionType, data) + return f.newNode(KindIntersectionType, data.AsNode()) } func (f *NodeFactory) UpdateIntersectionTypeNode(node *IntersectionTypeNode, types *TypeList) *Node { @@ -5216,7 +5259,7 @@ func (f *NodeFactory) NewConditionalTypeNode(checkType *TypeNode, extendsType *T data.ExtendsType = extendsType data.TrueType = trueType data.FalseType = falseType - return f.newNode(KindConditionalType, data) + return f.newNode(KindConditionalType, data.AsNode()) } func (f *NodeFactory) UpdateConditionalTypeNode(node *ConditionalTypeNode, checkType *TypeNode, extendsType *TypeNode, trueType *TypeNode, falseType *TypeNode) *Node { @@ -5259,7 +5302,7 @@ func (f *NodeFactory) NewTypeOperatorNode(operator Kind, typeNode *TypeNode) *No data := f.typeOperatorNodeArena.New() data.Operator = operator data.Type = typeNode - return f.newNode(KindTypeOperator, data) + return f.newNode(KindTypeOperator, data.AsNode()) } func (f *NodeFactory) UpdateTypeOperatorNode(node *TypeOperatorNode, operator Kind, typeNode *TypeNode) *Node { @@ -5297,7 +5340,7 @@ type InferTypeNode struct { func (f *NodeFactory) NewInferTypeNode(typeParameter *TypeParameterDeclarationNode) *Node { data := &InferTypeNode{} data.TypeParameter = typeParameter - return f.newNode(KindInferType, data) + return f.newNode(KindInferType, data.AsNode()) } func (f *NodeFactory) UpdateInferTypeNode(node *InferTypeNode, typeParameter *TypeParameterDeclarationNode) *Node { @@ -5335,7 +5378,7 @@ type ArrayTypeNode struct { func (f *NodeFactory) NewArrayTypeNode(elementType *TypeNode) *Node { data := f.arrayTypeNodeArena.New() data.ElementType = elementType - return f.newNode(KindArrayType, data) + return f.newNode(KindArrayType, data.AsNode()) } func (f *NodeFactory) UpdateArrayTypeNode(node *ArrayTypeNode, elementType *TypeNode) *Node { @@ -5375,7 +5418,7 @@ func (f *NodeFactory) NewIndexedAccessTypeNode(objectType *TypeNode, indexType * data := f.indexedAccessTypeNodeArena.New() data.ObjectType = objectType data.IndexType = indexType - return f.newNode(KindIndexedAccessType, data) + return f.newNode(KindIndexedAccessType, data.AsNode()) } func (f *NodeFactory) UpdateIndexedAccessTypeNode(node *IndexedAccessTypeNode, objectType *TypeNode, indexType *TypeNode) *Node { @@ -5414,7 +5457,7 @@ func (f *NodeFactory) NewTypeReferenceNode(typeName *EntityName, typeArguments * data := f.typeReferenceNodeArena.New() data.TypeName = typeName data.TypeArguments = typeArguments - return f.newNode(KindTypeReference, data) + return f.newNode(KindTypeReference, data.AsNode()) } func (f *NodeFactory) UpdateTypeReferenceNode(node *TypeReferenceNode, typeName *EntityName, typeArguments *TypeList) *Node { @@ -5455,7 +5498,7 @@ func (f *NodeFactory) NewExpressionWithTypeArguments(expression *Expression, typ data := f.expressionWithTypeArgumentsArena.New() data.Expression = expression data.TypeArguments = typeArguments - return f.newNode(KindExpressionWithTypeArguments, data) + return f.newNode(KindExpressionWithTypeArguments, data.AsNode()) } func (f *NodeFactory) UpdateExpressionWithTypeArguments(node *ExpressionWithTypeArguments, expression *Expression, typeArguments *TypeList) *Node { @@ -5493,7 +5536,7 @@ type LiteralTypeNode struct { func (f *NodeFactory) NewLiteralTypeNode(literal *Node) *Node { data := f.literalTypeNodeArena.New() data.Literal = literal - return f.newNode(KindLiteralType, data) + return f.newNode(KindLiteralType, data.AsNode()) } func (f *NodeFactory) UpdateLiteralTypeNode(node *LiteralTypeNode, literal *Node) *Node { @@ -5529,7 +5572,7 @@ type ThisTypeNode struct { func (f *NodeFactory) NewThisTypeNode() *Node { data := &ThisTypeNode{} - return f.newNode(KindThisType, data) + return f.newNode(KindThisType, data.AsNode()) } func (node *ThisTypeNode) Clone(f NodeFactoryCoercible) *Node { @@ -5556,7 +5599,7 @@ func (f *NodeFactory) NewTypePredicateNode(assertsModifier *AssertsKeyword, para data.AssertsModifier = assertsModifier data.ParameterName = parameterName data.Type = typeNode - return f.newNode(KindTypePredicate, data) + return f.newNode(KindTypePredicate, data.AsNode()) } func (f *NodeFactory) UpdateTypePredicateNode(node *TypePredicateNode, assertsModifier *AssertsKeyword, parameterName *TypePredicateParameterName, typeNode *TypeNode) *Node { @@ -5597,7 +5640,7 @@ func (f *NodeFactory) NewImportAttribute(name *ImportAttributeName, value *Expre data := &ImportAttribute{} data.name = name data.Value = value - return f.newNode(KindImportAttribute, data) + return f.newNode(KindImportAttribute, data.AsNode()) } func (f *NodeFactory) UpdateImportAttribute(node *ImportAttribute, name *ImportAttributeName, value *Expression) *Node { @@ -5649,7 +5692,7 @@ func (f *NodeFactory) NewImportAttributes(token Kind, attributes *ImportAttribut data.Token = token data.Attributes = attributes data.MultiLine = multiLine - return f.newNode(KindImportAttributes, data) + return f.newNode(KindImportAttributes, data.AsNode()) } func (f *NodeFactory) UpdateImportAttributes(node *ImportAttributes, token Kind, attributes *ImportAttributeList, multiLine bool) *Node { @@ -5692,7 +5735,7 @@ func (f *NodeFactory) NewTypeQueryNode(exprName *EntityName, typeArguments *Type data := &TypeQueryNode{} data.ExprName = exprName data.TypeArguments = typeArguments - return f.newNode(KindTypeQuery, data) + return f.newNode(KindTypeQuery, data.AsNode()) } func (f *NodeFactory) UpdateTypeQueryNode(node *TypeQueryNode, exprName *EntityName, typeArguments *TypeList) *Node { @@ -5742,7 +5785,7 @@ func (f *NodeFactory) NewMappedTypeNode(readonlyToken *TokenNode, typeParameter data.QuestionToken = questionToken data.Type = typeNode data.Members = members - return f.newNode(KindMappedType, data) + return f.newNode(KindMappedType, data.AsNode()) } func (f *NodeFactory) UpdateMappedTypeNode(node *MappedTypeNode, readonlyToken *TokenNode, typeParameter *TypeParameterDeclarationNode, nameType *TypeNode, questionToken *TokenNode, typeNode *TypeNode, members *TypeElementList) *Node { @@ -5786,7 +5829,7 @@ type TypeLiteralNode struct { func (f *NodeFactory) NewTypeLiteralNode(members *TypeElementList) *Node { data := f.typeLiteralNodeArena.New() data.Members = members - return f.newNode(KindTypeLiteral, data) + return f.newNode(KindTypeLiteral, data.AsNode()) } func (f *NodeFactory) UpdateTypeLiteralNode(node *TypeLiteralNode, members *TypeElementList) *Node { @@ -5824,7 +5867,7 @@ type TupleTypeNode struct { func (f *NodeFactory) NewTupleTypeNode(elements *TypeList) *Node { data := &TupleTypeNode{} data.Elements = elements - return f.newNode(KindTupleType, data) + return f.newNode(KindTupleType, data.AsNode()) } func (f *NodeFactory) UpdateTupleTypeNode(node *TupleTypeNode, elements *TypeList) *Node { @@ -5869,7 +5912,7 @@ func (f *NodeFactory) NewNamedTupleMember(dotDotDotToken *DotDotDotToken, name * data.name = name data.QuestionToken = questionToken data.Type = typeNode - return f.newNode(KindNamedTupleMember, data) + return f.newNode(KindNamedTupleMember, data.AsNode()) } func (f *NodeFactory) UpdateNamedTupleMember(node *NamedTupleMember, dotDotDotToken *DotDotDotToken, name *IdentifierNode, questionToken *QuestionToken, typeNode *TypeNode) *Node { @@ -5914,7 +5957,7 @@ type OptionalTypeNode struct { func (f *NodeFactory) NewOptionalTypeNode(typeNode *TypeNode) *Node { data := &OptionalTypeNode{} data.Type = typeNode - return f.newNode(KindOptionalType, data) + return f.newNode(KindOptionalType, data.AsNode()) } func (f *NodeFactory) UpdateOptionalTypeNode(node *OptionalTypeNode, typeNode *TypeNode) *Node { @@ -5952,7 +5995,7 @@ type RestTypeNode struct { func (f *NodeFactory) NewRestTypeNode(typeNode *TypeNode) *Node { data := &RestTypeNode{} data.Type = typeNode - return f.newNode(KindRestType, data) + return f.newNode(KindRestType, data.AsNode()) } func (f *NodeFactory) UpdateRestTypeNode(node *RestTypeNode, typeNode *TypeNode) *Node { @@ -5990,7 +6033,7 @@ type ParenthesizedTypeNode struct { func (f *NodeFactory) NewParenthesizedTypeNode(typeNode *TypeNode) *Node { data := f.parenthesizedTypeNodeArena.New() data.Type = typeNode - return f.newNode(KindParenthesizedType, data) + return f.newNode(KindParenthesizedType, data.AsNode()) } func (f *NodeFactory) UpdateParenthesizedTypeNode(node *ParenthesizedTypeNode, typeNode *TypeNode) *Node { @@ -6029,7 +6072,7 @@ func (f *NodeFactory) NewFunctionTypeNode(typeParameters *TypeParameterList, par data.TypeParameters = typeParameters data.Parameters = parameters data.Type = typeNode - return f.newNode(KindFunctionType, data) + return f.newNode(KindFunctionType, data.AsNode()) } func (f *NodeFactory) UpdateFunctionTypeNode(node *FunctionTypeNode, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode) *Node { @@ -6069,7 +6112,7 @@ func (f *NodeFactory) NewConstructorTypeNode(modifiers *ModifierList, typeParame data.TypeParameters = typeParameters data.Parameters = parameters data.Type = typeNode - return f.newNode(KindConstructorType, data) + return f.newNode(KindConstructorType, data.AsNode()) } func (f *NodeFactory) UpdateConstructorTypeNode(node *ConstructorTypeNode, modifiers *ModifierList, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode) *Node { @@ -6113,7 +6156,7 @@ func (f *NodeFactory) NewTemplateHead(text string, rawText string, templateFlags data.RawText = rawText data.TemplateFlags = templateFlags & TokenFlagsTemplateLiteralLikeFlags f.textCount++ - return f.newNode(KindTemplateHead, data) + return f.newNode(KindTemplateHead, data.AsNode()) } func (node *TemplateHead) Clone(f NodeFactoryCoercible) *Node { @@ -6139,7 +6182,7 @@ func (f *NodeFactory) NewTemplateMiddle(text string, rawText string, templateFla data.RawText = rawText data.TemplateFlags = templateFlags & TokenFlagsTemplateLiteralLikeFlags f.textCount++ - return f.newNode(KindTemplateMiddle, data) + return f.newNode(KindTemplateMiddle, data.AsNode()) } func (node *TemplateMiddle) Clone(f NodeFactoryCoercible) *Node { @@ -6165,7 +6208,7 @@ func (f *NodeFactory) NewTemplateTail(text string, rawText string, templateFlags data.RawText = rawText data.TemplateFlags = templateFlags & TokenFlagsTemplateLiteralLikeFlags f.textCount++ - return f.newNode(KindTemplateTail, data) + return f.newNode(KindTemplateTail, data.AsNode()) } func (node *TemplateTail) Clone(f NodeFactoryCoercible) *Node { @@ -6190,7 +6233,7 @@ func (f *NodeFactory) NewTemplateLiteralTypeNode(head *TemplateHeadNode, templat data := &TemplateLiteralTypeNode{} data.Head = head data.TemplateSpans = templateSpans - return f.newNode(KindTemplateLiteralType, data) + return f.newNode(KindTemplateLiteralType, data.AsNode()) } func (f *NodeFactory) UpdateTemplateLiteralTypeNode(node *TemplateLiteralTypeNode, head *TemplateHeadNode, templateSpans *TemplateLiteralTypeSpanList) *Node { @@ -6230,7 +6273,7 @@ func (f *NodeFactory) NewTemplateLiteralTypeSpan(typeNode *TypeNode, literal *Te data := &TemplateLiteralTypeSpan{} data.Type = typeNode data.Literal = literal - return f.newNode(KindTemplateLiteralTypeSpan, data) + return f.newNode(KindTemplateLiteralTypeSpan, data.AsNode()) } func (f *NodeFactory) UpdateTemplateLiteralTypeSpan(node *TemplateLiteralTypeSpan, typeNode *TypeNode, literal *TemplateMiddleOrTail) *Node { @@ -6272,7 +6315,7 @@ func (f *NodeFactory) NewSyntheticExpression(typeNode any, isSpread bool, tupleN data.Type = typeNode data.IsSpread = isSpread data.TupleNameSource = tupleNameSource - return f.newNode(KindSyntheticExpression, data) + return f.newNode(KindSyntheticExpression, data.AsNode()) } func (f *NodeFactory) UpdateSyntheticExpression(node *SyntheticExpression, typeNode any, isSpread bool, tupleNameSource *Node) *Node { @@ -6310,7 +6353,7 @@ type PartiallyEmittedExpression struct { func (f *NodeFactory) NewPartiallyEmittedExpression(expression *Expression) *Node { data := &PartiallyEmittedExpression{} data.Expression = expression - return f.newNode(KindPartiallyEmittedExpression, data) + return f.newNode(KindPartiallyEmittedExpression, data.AsNode()) } func (f *NodeFactory) UpdatePartiallyEmittedExpression(node *PartiallyEmittedExpression, expression *Expression) *Node { @@ -6357,7 +6400,7 @@ func (f *NodeFactory) NewJsxElement(openingElement *JsxOpeningElementNode, child data.OpeningElement = openingElement data.Children = children data.ClosingElement = closingElement - return f.newNode(KindJsxElement, data) + return f.newNode(KindJsxElement, data.AsNode()) } func (f *NodeFactory) UpdateJsxElement(node *JsxElement, openingElement *JsxOpeningElementNode, children *JsxChildList, closingElement *JsxClosingElementNode) *Node { @@ -6397,7 +6440,7 @@ type JsxAttributes struct { func (f *NodeFactory) NewJsxAttributes(properties *JsxAttributeList) *Node { data := &JsxAttributes{} data.Properties = properties - return f.newNode(KindJsxAttributes, data) + return f.newNode(KindJsxAttributes, data.AsNode()) } func (f *NodeFactory) UpdateJsxAttributes(node *JsxAttributes, properties *JsxAttributeList) *Node { @@ -6438,7 +6481,7 @@ func (f *NodeFactory) NewJsxNamespacedName(namespace *IdentifierNode, name *Iden data := &JsxNamespacedName{} data.Namespace = namespace data.name = name - return f.newNode(KindJsxNamespacedName, data) + return f.newNode(KindJsxNamespacedName, data.AsNode()) } func (f *NodeFactory) UpdateJsxNamespacedName(node *JsxNamespacedName, namespace *IdentifierNode, name *IdentifierNode) *Node { @@ -6485,7 +6528,7 @@ func (f *NodeFactory) NewJsxOpeningElement(tagName *JsxTagNameExpression, typeAr data.TagName = tagName data.TypeArguments = typeArguments data.Attributes = attributes - return f.newNode(KindJsxOpeningElement, data) + return f.newNode(KindJsxOpeningElement, data.AsNode()) } func (f *NodeFactory) UpdateJsxOpeningElement(node *JsxOpeningElement, tagName *JsxTagNameExpression, typeArguments *TypeList, attributes *JsxAttributesNode) *Node { @@ -6528,7 +6571,7 @@ func (f *NodeFactory) NewJsxSelfClosingElement(tagName *JsxTagNameExpression, ty data.TagName = tagName data.TypeArguments = typeArguments data.Attributes = attributes - return f.newNode(KindJsxSelfClosingElement, data) + return f.newNode(KindJsxSelfClosingElement, data.AsNode()) } func (f *NodeFactory) UpdateJsxSelfClosingElement(node *JsxSelfClosingElement, tagName *JsxTagNameExpression, typeArguments *TypeList, attributes *JsxAttributesNode) *Node { @@ -6571,7 +6614,7 @@ func (f *NodeFactory) NewJsxFragment(openingFragment *JsxOpeningFragmentNode, ch data.OpeningFragment = openingFragment data.Children = children data.ClosingFragment = closingFragment - return f.newNode(KindJsxFragment, data) + return f.newNode(KindJsxFragment, data.AsNode()) } func (f *NodeFactory) UpdateJsxFragment(node *JsxFragment, openingFragment *JsxOpeningFragmentNode, children *JsxChildList, closingFragment *JsxClosingFragmentNode) *Node { @@ -6607,7 +6650,7 @@ type JsxOpeningFragment struct { func (f *NodeFactory) NewJsxOpeningFragment() *Node { data := &JsxOpeningFragment{} - return f.newNode(KindJsxOpeningFragment, data) + return f.newNode(KindJsxOpeningFragment, data.AsNode()) } func (node *JsxOpeningFragment) Clone(f NodeFactoryCoercible) *Node { @@ -6628,7 +6671,7 @@ type JsxClosingFragment struct { func (f *NodeFactory) NewJsxClosingFragment() *Node { data := &JsxClosingFragment{} - return f.newNode(KindJsxClosingFragment, data) + return f.newNode(KindJsxClosingFragment, data.AsNode()) } func (node *JsxClosingFragment) Clone(f NodeFactoryCoercible) *Node { @@ -6655,7 +6698,7 @@ func (f *NodeFactory) NewJsxAttribute(name *JsxAttributeName, initializer *JsxAt data := &JsxAttribute{} data.name = name data.Initializer = initializer - return f.newNode(KindJsxAttribute, data) + return f.newNode(KindJsxAttribute, data.AsNode()) } func (f *NodeFactory) UpdateJsxAttribute(node *JsxAttribute, name *JsxAttributeName, initializer *JsxAttributeValue) *Node { @@ -6698,7 +6741,7 @@ type JsxSpreadAttribute struct { func (f *NodeFactory) NewJsxSpreadAttribute(expression *Expression) *Node { data := &JsxSpreadAttribute{} data.Expression = expression - return f.newNode(KindJsxSpreadAttribute, data) + return f.newNode(KindJsxSpreadAttribute, data.AsNode()) } func (f *NodeFactory) UpdateJsxSpreadAttribute(node *JsxSpreadAttribute, expression *Expression) *Node { @@ -6736,7 +6779,7 @@ type JsxClosingElement struct { func (f *NodeFactory) NewJsxClosingElement(tagName *JsxTagNameExpression) *Node { data := &JsxClosingElement{} data.TagName = tagName - return f.newNode(KindJsxClosingElement, data) + return f.newNode(KindJsxClosingElement, data.AsNode()) } func (f *NodeFactory) UpdateJsxClosingElement(node *JsxClosingElement, tagName *JsxTagNameExpression) *Node { @@ -6776,7 +6819,7 @@ func (f *NodeFactory) NewJsxExpression(dotDotDotToken *DotDotDotToken, expressio data := &JsxExpression{} data.DotDotDotToken = dotDotDotToken data.Expression = expression - return f.newNode(KindJsxExpression, data) + return f.newNode(KindJsxExpression, data.AsNode()) } func (f *NodeFactory) UpdateJsxExpression(node *JsxExpression, dotDotDotToken *DotDotDotToken, expression *Expression) *Node { @@ -6817,7 +6860,7 @@ func (f *NodeFactory) NewJsxText(text string, containsOnlyTriviaWhiteSpaces bool data.Text = text data.ContainsOnlyTriviaWhiteSpaces = containsOnlyTriviaWhiteSpaces f.textCount++ - return f.newNode(KindJsxText, data) + return f.newNode(KindJsxText, data.AsNode()) } func (node *JsxText) Clone(f NodeFactoryCoercible) *Node { @@ -6840,7 +6883,7 @@ type SyntaxList struct { func (f *NodeFactory) NewSyntaxList(children []*Node) *Node { data := &SyntaxList{} data.Children = children - return f.newNode(KindSyntaxList, data) + return f.newNode(KindSyntaxList, data.AsNode()) } func (f *NodeFactory) UpdateSyntaxList(node *SyntaxList, children []*Node) *Node { @@ -6881,7 +6924,7 @@ func (f *NodeFactory) NewJSDoc(comment *NodeList, tags *NodeList) *Node { data := f.jsdocArena.New() data.Comment = comment data.Tags = tags - return f.newNode(KindJSDoc, data) + return f.newNode(KindJSDoc, data.AsNode()) } func (f *NodeFactory) UpdateJSDoc(node *JSDoc, comment *NodeList, tags *NodeList) *Node { @@ -6919,7 +6962,7 @@ type JSDocTypeExpression struct { func (f *NodeFactory) NewJSDocTypeExpression(typeNode *TypeNode) *Node { data := &JSDocTypeExpression{} data.Type = typeNode - return f.newNode(KindJSDocTypeExpression, data) + return f.newNode(KindJSDocTypeExpression, data.AsNode()) } func (f *NodeFactory) UpdateJSDocTypeExpression(node *JSDocTypeExpression, typeNode *TypeNode) *Node { @@ -6957,7 +7000,7 @@ type JSDocNonNullableType struct { func (f *NodeFactory) NewJSDocNonNullableType(typeNode *TypeNode) *Node { data := &JSDocNonNullableType{} data.Type = typeNode - return f.newNode(KindJSDocNonNullableType, data) + return f.newNode(KindJSDocNonNullableType, data.AsNode()) } func (f *NodeFactory) UpdateJSDocNonNullableType(node *JSDocNonNullableType, typeNode *TypeNode) *Node { @@ -6995,7 +7038,7 @@ type JSDocNullableType struct { func (f *NodeFactory) NewJSDocNullableType(typeNode *TypeNode) *Node { data := &JSDocNullableType{} data.Type = typeNode - return f.newNode(KindJSDocNullableType, data) + return f.newNode(KindJSDocNullableType, data.AsNode()) } func (f *NodeFactory) UpdateJSDocNullableType(node *JSDocNullableType, typeNode *TypeNode) *Node { @@ -7031,7 +7074,7 @@ type JSDocAllType struct { func (f *NodeFactory) NewJSDocAllType() *Node { data := &JSDocAllType{} - return f.newNode(KindJSDocAllType, data) + return f.newNode(KindJSDocAllType, data.AsNode()) } func (node *JSDocAllType) Clone(f NodeFactoryCoercible) *Node { @@ -7054,7 +7097,7 @@ type JSDocVariadicType struct { func (f *NodeFactory) NewJSDocVariadicType(typeNode *TypeNode) *Node { data := &JSDocVariadicType{} data.Type = typeNode - return f.newNode(KindJSDocVariadicType, data) + return f.newNode(KindJSDocVariadicType, data.AsNode()) } func (f *NodeFactory) UpdateJSDocVariadicType(node *JSDocVariadicType, typeNode *TypeNode) *Node { @@ -7092,7 +7135,7 @@ type JSDocOptionalType struct { func (f *NodeFactory) NewJSDocOptionalType(typeNode *TypeNode) *Node { data := &JSDocOptionalType{} data.Type = typeNode - return f.newNode(KindJSDocOptionalType, data) + return f.newNode(KindJSDocOptionalType, data.AsNode()) } func (f *NodeFactory) UpdateJSDocOptionalType(node *JSDocOptionalType, typeNode *TypeNode) *Node { @@ -7132,7 +7175,7 @@ func (f *NodeFactory) NewJSDocTypeTag(tagName *IdentifierNode, typeExpression *N data.TagName = tagName data.TypeExpression = typeExpression data.Comment = comment - return f.newNode(KindJSDocTypeTag, data) + return f.newNode(KindJSDocTypeTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocTypeTag(node *JSDocTypeTag, tagName *IdentifierNode, typeExpression *Node, comment *NodeList) *Node { @@ -7170,7 +7213,7 @@ func (f *NodeFactory) NewJSDocUnknownTag(tagName *IdentifierNode, comment *NodeL data := f.jsdocUnknownTagArena.New() data.TagName = tagName data.Comment = comment - return f.newNode(KindJSDocUnknownTag, data) + return f.newNode(KindJSDocUnknownTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocUnknownTag(node *JSDocUnknownTag, tagName *IdentifierNode, comment *NodeList) *Node { @@ -7212,7 +7255,7 @@ func (f *NodeFactory) NewJSDocTemplateTag(tagName *IdentifierNode, constraint *N data.Constraint = constraint data.TypeParameters = typeParameters data.Comment = comment - return f.newNode(KindJSDocTemplateTag, data) + return f.newNode(KindJSDocTemplateTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocTemplateTag(node *JSDocTemplateTag, tagName *IdentifierNode, constraint *Node, typeParameters *TypeParameterList, comment *NodeList) *Node { @@ -7255,7 +7298,7 @@ func (f *NodeFactory) NewJSDocReturnTag(tagName *IdentifierNode, typeExpression data.TagName = tagName data.TypeExpression = typeExpression data.Comment = comment - return f.newNode(KindJSDocReturnTag, data) + return f.newNode(KindJSDocReturnTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocReturnTag(node *JSDocReturnTag, tagName *IdentifierNode, typeExpression *TypeNode, comment *NodeList) *Node { @@ -7293,7 +7336,7 @@ func (f *NodeFactory) NewJSDocPublicTag(tagName *IdentifierNode, comment *NodeLi data := &JSDocPublicTag{} data.TagName = tagName data.Comment = comment - return f.newNode(KindJSDocPublicTag, data) + return f.newNode(KindJSDocPublicTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocPublicTag(node *JSDocPublicTag, tagName *IdentifierNode, comment *NodeList) *Node { @@ -7331,7 +7374,7 @@ func (f *NodeFactory) NewJSDocPrivateTag(tagName *IdentifierNode, comment *NodeL data := &JSDocPrivateTag{} data.TagName = tagName data.Comment = comment - return f.newNode(KindJSDocPrivateTag, data) + return f.newNode(KindJSDocPrivateTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocPrivateTag(node *JSDocPrivateTag, tagName *IdentifierNode, comment *NodeList) *Node { @@ -7369,7 +7412,7 @@ func (f *NodeFactory) NewJSDocProtectedTag(tagName *IdentifierNode, comment *Nod data := &JSDocProtectedTag{} data.TagName = tagName data.Comment = comment - return f.newNode(KindJSDocProtectedTag, data) + return f.newNode(KindJSDocProtectedTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocProtectedTag(node *JSDocProtectedTag, tagName *IdentifierNode, comment *NodeList) *Node { @@ -7407,7 +7450,7 @@ func (f *NodeFactory) NewJSDocReadonlyTag(tagName *IdentifierNode, comment *Node data := &JSDocReadonlyTag{} data.TagName = tagName data.Comment = comment - return f.newNode(KindJSDocReadonlyTag, data) + return f.newNode(KindJSDocReadonlyTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocReadonlyTag(node *JSDocReadonlyTag, tagName *IdentifierNode, comment *NodeList) *Node { @@ -7445,7 +7488,7 @@ func (f *NodeFactory) NewJSDocOverrideTag(tagName *IdentifierNode, comment *Node data := &JSDocOverrideTag{} data.TagName = tagName data.Comment = comment - return f.newNode(KindJSDocOverrideTag, data) + return f.newNode(KindJSDocOverrideTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocOverrideTag(node *JSDocOverrideTag, tagName *IdentifierNode, comment *NodeList) *Node { @@ -7483,7 +7526,7 @@ func (f *NodeFactory) NewJSDocDeprecatedTag(tagName *IdentifierNode, comment *No data := f.jsdocDeprecatedTagArena.New() data.TagName = tagName data.Comment = comment - return f.newNode(KindJSDocDeprecatedTag, data) + return f.newNode(KindJSDocDeprecatedTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocDeprecatedTag(node *JSDocDeprecatedTag, tagName *IdentifierNode, comment *NodeList) *Node { @@ -7523,7 +7566,7 @@ func (f *NodeFactory) NewJSDocSeeTag(tagName *IdentifierNode, nameExpression *Ty data.TagName = tagName data.NameExpression = nameExpression data.Comment = comment - return f.newNode(KindJSDocSeeTag, data) + return f.newNode(KindJSDocSeeTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocSeeTag(node *JSDocSeeTag, tagName *IdentifierNode, nameExpression *TypeNode, comment *NodeList) *Node { @@ -7563,7 +7606,7 @@ func (f *NodeFactory) NewJSDocImplementsTag(tagName *IdentifierNode, className * data.TagName = tagName data.ClassName = className data.Comment = comment - return f.newNode(KindJSDocImplementsTag, data) + return f.newNode(KindJSDocImplementsTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocImplementsTag(node *JSDocImplementsTag, tagName *IdentifierNode, className *ExpressionWithTypeArgumentsNode, comment *NodeList) *Node { @@ -7603,7 +7646,7 @@ func (f *NodeFactory) NewJSDocAugmentsTag(tagName *IdentifierNode, className *Ex data.TagName = tagName data.ClassName = className data.Comment = comment - return f.newNode(KindJSDocAugmentsTag, data) + return f.newNode(KindJSDocAugmentsTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocAugmentsTag(node *JSDocAugmentsTag, tagName *IdentifierNode, className *ExpressionWithTypeArgumentsNode, comment *NodeList) *Node { @@ -7643,7 +7686,7 @@ func (f *NodeFactory) NewJSDocSatisfiesTag(tagName *IdentifierNode, typeExpressi data.TagName = tagName data.TypeExpression = typeExpression data.Comment = comment - return f.newNode(KindJSDocSatisfiesTag, data) + return f.newNode(KindJSDocSatisfiesTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocSatisfiesTag(node *JSDocSatisfiesTag, tagName *IdentifierNode, typeExpression *TypeNode, comment *NodeList) *Node { @@ -7683,7 +7726,7 @@ func (f *NodeFactory) NewJSDocThrowsTag(tagName *IdentifierNode, typeExpression data.TagName = tagName data.TypeExpression = typeExpression data.Comment = comment - return f.newNode(KindJSDocThrowsTag, data) + return f.newNode(KindJSDocThrowsTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocThrowsTag(node *JSDocThrowsTag, tagName *IdentifierNode, typeExpression *TypeNode, comment *NodeList) *Node { @@ -7723,7 +7766,7 @@ func (f *NodeFactory) NewJSDocThisTag(tagName *IdentifierNode, typeExpression *T data.TagName = tagName data.TypeExpression = typeExpression data.Comment = comment - return f.newNode(KindJSDocThisTag, data) + return f.newNode(KindJSDocThisTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocThisTag(node *JSDocThisTag, tagName *IdentifierNode, typeExpression *TypeNode, comment *NodeList) *Node { @@ -7767,7 +7810,7 @@ func (f *NodeFactory) NewJSDocImportTag(tagName *IdentifierNode, importClause *I data.ModuleSpecifier = moduleSpecifier data.Attributes = attributes data.Comment = comment - return f.newNode(KindJSDocImportTag, data) + return f.newNode(KindJSDocImportTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocImportTag(node *JSDocImportTag, tagName *IdentifierNode, importClause *ImportClauseNode, moduleSpecifier *Expression, attributes *ImportAttributesNode, comment *NodeList) *Node { @@ -7813,7 +7856,7 @@ func (f *NodeFactory) NewJSDocCallbackTag(tagName *IdentifierNode, typeExpressio data.TypeExpression = typeExpression data.name = name data.Comment = comment - return f.newNode(KindJSDocCallbackTag, data) + return f.newNode(KindJSDocCallbackTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocCallbackTag(node *JSDocCallbackTag, tagName *IdentifierNode, typeExpression *TypeNode, name *JSDocFullName, comment *NodeList) *Node { @@ -7860,7 +7903,7 @@ func (f *NodeFactory) NewJSDocOverloadTag(tagName *IdentifierNode, typeExpressio data.TagName = tagName data.TypeExpression = typeExpression data.Comment = comment - return f.newNode(KindJSDocOverloadTag, data) + return f.newNode(KindJSDocOverloadTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocOverloadTag(node *JSDocOverloadTag, tagName *IdentifierNode, typeExpression *TypeNode, comment *NodeList) *Node { @@ -7902,7 +7945,7 @@ func (f *NodeFactory) NewJSDocTypedefTag(tagName *IdentifierNode, typeExpression data.TypeExpression = typeExpression data.name = name data.Comment = comment - return f.newNode(KindJSDocTypedefTag, data) + return f.newNode(KindJSDocTypedefTag, data.AsNode()) } func (f *NodeFactory) UpdateJSDocTypedefTag(node *JSDocTypedefTag, tagName *IdentifierNode, typeExpression *Node, name *JSDocFullName, comment *NodeList) *Node { @@ -7950,7 +7993,7 @@ func (f *NodeFactory) NewJSDocSignature(typeParameters *TypeParameterList, param data.TypeParameters = typeParameters data.Parameters = parameters data.Type = typeNode - return f.newNode(KindJSDocSignature, data) + return f.newNode(KindJSDocSignature, data.AsNode()) } func (f *NodeFactory) UpdateJSDocSignature(node *JSDocSignature, typeParameters *TypeParameterList, parameters *ParameterList, typeNode *TypeNode) *Node { @@ -7988,7 +8031,7 @@ type JSDocNameReference struct { func (f *NodeFactory) NewJSDocNameReference(name *EntityName) *Node { data := &JSDocNameReference{} data.name = name - return f.newNode(KindJSDocNameReference, data) + return f.newNode(KindJSDocNameReference, data.AsNode()) } func (f *NodeFactory) UpdateJSDocNameReference(node *JSDocNameReference, name *EntityName) *Node { @@ -8049,7 +8092,7 @@ func (f *NodeFactory) NewModuleDeclaration(modifiers *ModifierList, keyword Kind data.Keyword = keyword data.name = name data.Body = body - return f.newNode(KindModuleDeclaration, data) + return f.newNode(KindModuleDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateModuleDeclaration(node *ModuleDeclaration, modifiers *ModifierList, keyword Kind, name *ModuleName, body *ModuleBody) *Node { @@ -8100,7 +8143,7 @@ func (f *NodeFactory) NewImportEqualsDeclaration(modifiers *ModifierList, isType data.IsTypeOnly = isTypeOnly data.name = name data.ModuleReference = moduleReference - return f.newNode(KindImportEqualsDeclaration, data) + return f.newNode(KindImportEqualsDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateImportEqualsDeclaration(node *ImportEqualsDeclaration, modifiers *ModifierList, isTypeOnly bool, name *IdentifierNode, moduleReference *ModuleReference) *Node { @@ -8152,7 +8195,7 @@ func (f *NodeFactory) NewExportDeclaration(modifiers *ModifierList, isTypeOnly b data.ExportClause = exportClause data.ModuleSpecifier = moduleSpecifier data.Attributes = attributes - return f.newNode(KindExportDeclaration, data) + return f.newNode(KindExportDeclaration, data.AsNode()) } func (f *NodeFactory) UpdateExportDeclaration(node *ExportDeclaration, modifiers *ModifierList, isTypeOnly bool, exportClause *NamedExportBindings, moduleSpecifier *Expression, attributes *ImportAttributesNode) *Node { @@ -8200,7 +8243,7 @@ func (f *NodeFactory) NewImportTypeNode(isTypeOf bool, argument *TypeNode, attri data.Attributes = attributes data.Qualifier = qualifier data.TypeArguments = typeArguments - return f.newNode(KindImportType, data) + return f.newNode(KindImportType, data.AsNode()) } func (f *NodeFactory) UpdateImportTypeNode(node *ImportTypeNode, isTypeOf bool, argument *TypeNode, attributes *ImportAttributesNode, qualifier *EntityName, typeArguments *TypeList) *Node { @@ -8248,7 +8291,7 @@ func (f *NodeFactory) NewImportClause(phaseModifier ImportPhaseModifierSyntaxKin data.PhaseModifier = phaseModifier data.name = name data.NamedBindings = namedBindings - return f.newNode(KindImportClause, data) + return f.newNode(KindImportClause, data.AsNode()) } func (f *NodeFactory) UpdateImportClause(node *ImportClause, phaseModifier ImportPhaseModifierSyntaxKind, name *IdentifierNode, namedBindings *NamedImportBindings) *Node { @@ -8297,7 +8340,7 @@ func (f *NodeFactory) NewImportSpecifier(isTypeOnly bool, propertyName *ModuleEx data.IsTypeOnly = isTypeOnly data.PropertyName = propertyName data.name = name - return f.newNode(KindImportSpecifier, data) + return f.newNode(KindImportSpecifier, data.AsNode()) } func (f *NodeFactory) UpdateImportSpecifier(node *ImportSpecifier, isTypeOnly bool, propertyName *ModuleExportName, name *IdentifierNode) *Node { @@ -8339,7 +8382,7 @@ func (f *NodeFactory) NewJSDocText(text []string) *Node { data := f.jsdocTextArena.New() data.text = text f.textCount++ - return f.newNode(KindJSDocText, data) + return f.newNode(KindJSDocText, data.AsNode()) } func (node *JSDocText) Clone(f NodeFactoryCoercible) *Node { @@ -8364,7 +8407,7 @@ func (f *NodeFactory) NewJSDocLink(name *EntityName, text []string) *Node { data.name = name data.text = text f.textCount++ - return f.newNode(KindJSDocLink, data) + return f.newNode(KindJSDocLink, data.AsNode()) } func (f *NodeFactory) UpdateJSDocLink(node *JSDocLink, name *EntityName, text []string) *Node { @@ -8408,7 +8451,7 @@ func (f *NodeFactory) NewJSDocLinkPlain(name *EntityName, text []string) *Node { data.name = name data.text = text f.textCount++ - return f.newNode(KindJSDocLinkPlain, data) + return f.newNode(KindJSDocLinkPlain, data.AsNode()) } func (f *NodeFactory) UpdateJSDocLinkPlain(node *JSDocLinkPlain, name *EntityName, text []string) *Node { @@ -8452,7 +8495,7 @@ func (f *NodeFactory) NewJSDocLinkCode(name *EntityName, text []string) *Node { data.name = name data.text = text f.textCount++ - return f.newNode(KindJSDocLinkCode, data) + return f.newNode(KindJSDocLinkCode, data.AsNode()) } func (f *NodeFactory) UpdateJSDocLinkCode(node *JSDocLinkCode, name *EntityName, text []string) *Node { @@ -8504,7 +8547,7 @@ func (f *NodeFactory) NewTypeParameterDeclaration(modifiers *ModifierList, name data.Constraint = constraint data.Expression = expression data.DefaultType = defaultType - return f.newNode(KindTypeParameter, data) + return f.newNode(KindTypeParameter, data.AsNode()) } func (f *NodeFactory) UpdateTypeParameterDeclaration(node *TypeParameterDeclaration, modifiers *ModifierList, name *IdentifierNode, constraint *TypeNode, expression *Expression, defaultType *TypeNode) *Node { @@ -8552,7 +8595,7 @@ func (f *NodeFactory) NewSyntheticReferenceExpression(expression *Expression, th data := &SyntheticReferenceExpression{} data.Expression = expression data.ThisArg = thisArg - return f.newNode(KindSyntheticReferenceExpression, data) + return f.newNode(KindSyntheticReferenceExpression, data.AsNode()) } func (f *NodeFactory) UpdateSyntheticReferenceExpression(node *SyntheticReferenceExpression, expression *Expression, thisArg *Expression) *Node { @@ -8598,7 +8641,7 @@ func (f *NodeFactory) NewJSDocTypeLiteral(jsdocPropertyTags []*Node, isArrayType data := &JSDocTypeLiteral{} data.JSDocPropertyTags = jsdocPropertyTags data.IsArrayType = isArrayType - return f.newNode(KindJSDocTypeLiteral, data) + return f.newNode(KindJSDocTypeLiteral, data.AsNode()) } func (f *NodeFactory) UpdateJSDocTypeLiteral(node *JSDocTypeLiteral, jsdocPropertyTags []*Node, isArrayType bool) *Node { @@ -8645,7 +8688,7 @@ func (f *NodeFactory) NewJSDocParameterOrPropertyTag(kind Kind, tagName *Identif data.TypeExpression = typeExpression data.IsNameFirst = isNameFirst data.Comment = comment - return f.newNode(kind, data) + return f.newNode(kind, data.AsNode()) } func (f *NodeFactory) UpdateJSDocParameterOrPropertyTag(node *JSDocParameterOrPropertyTag, tagName *IdentifierNode, name *EntityName, isBracketed bool, typeExpression *TypeNode, isNameFirst bool, comment *NodeList) *Node { @@ -8686,1114 +8729,4310 @@ func IsJSDocPropertyTag(node *Node) bool { func (n *Node) ForEachChild(v Visitor) bool { switch n.Kind { case KindQualifiedName: - return n.data.(*QualifiedName).ForEachChild(v) + return (*QualifiedName)(unsafe.Pointer(n)).ForEachChild(v) case KindComputedPropertyName: - return n.data.(*ComputedPropertyName).ForEachChild(v) + return (*ComputedPropertyName)(unsafe.Pointer(n)).ForEachChild(v) case KindDecorator: - return n.data.(*Decorator).ForEachChild(v) + return (*Decorator)(unsafe.Pointer(n)).ForEachChild(v) case KindIfStatement: - return n.data.(*IfStatement).ForEachChild(v) + return (*IfStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindDoStatement: - return n.data.(*DoStatement).ForEachChild(v) + return (*DoStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindWhileStatement: - return n.data.(*WhileStatement).ForEachChild(v) + return (*WhileStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindForStatement: - return n.data.(*ForStatement).ForEachChild(v) + return (*ForStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindForInStatement, KindForOfStatement: - return n.data.(*ForInOrOfStatement).ForEachChild(v) + return (*ForInOrOfStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindBreakStatement: - return n.data.(*BreakStatement).ForEachChild(v) + return (*BreakStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindContinueStatement: - return n.data.(*ContinueStatement).ForEachChild(v) + return (*ContinueStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindReturnStatement: - return n.data.(*ReturnStatement).ForEachChild(v) + return (*ReturnStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindWithStatement: - return n.data.(*WithStatement).ForEachChild(v) + return (*WithStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindSwitchStatement: - return n.data.(*SwitchStatement).ForEachChild(v) + return (*SwitchStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindCaseBlock: - return n.data.(*CaseBlock).ForEachChild(v) + return (*CaseBlock)(unsafe.Pointer(n)).ForEachChild(v) case KindCaseClause, KindDefaultClause: - return n.data.(*CaseOrDefaultClause).ForEachChild(v) + return (*CaseOrDefaultClause)(unsafe.Pointer(n)).ForEachChild(v) case KindThrowStatement: - return n.data.(*ThrowStatement).ForEachChild(v) + return (*ThrowStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindTryStatement: - return n.data.(*TryStatement).ForEachChild(v) + return (*TryStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindCatchClause: - return n.data.(*CatchClause).ForEachChild(v) + return (*CatchClause)(unsafe.Pointer(n)).ForEachChild(v) case KindLabeledStatement: - return n.data.(*LabeledStatement).ForEachChild(v) + return (*LabeledStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindExpressionStatement: - return n.data.(*ExpressionStatement).ForEachChild(v) + return (*ExpressionStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindBlock: - return n.data.(*Block).ForEachChild(v) + return (*Block)(unsafe.Pointer(n)).ForEachChild(v) case KindVariableStatement: - return n.data.(*VariableStatement).ForEachChild(v) + return (*VariableStatement)(unsafe.Pointer(n)).ForEachChild(v) case KindVariableDeclaration: - return n.data.(*VariableDeclaration).ForEachChild(v) + return (*VariableDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindVariableDeclarationList: - return n.data.(*VariableDeclarationList).ForEachChild(v) + return (*VariableDeclarationList)(unsafe.Pointer(n)).ForEachChild(v) case KindObjectBindingPattern, KindArrayBindingPattern: - return n.data.(*BindingPattern).ForEachChild(v) + return (*BindingPattern)(unsafe.Pointer(n)).ForEachChild(v) case KindParameter: - return n.data.(*ParameterDeclaration).ForEachChild(v) + return (*ParameterDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindBindingElement: - return n.data.(*BindingElement).ForEachChild(v) + return (*BindingElement)(unsafe.Pointer(n)).ForEachChild(v) case KindMissingDeclaration: - return n.data.(*MissingDeclaration).ForEachChild(v) + return (*MissingDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindFunctionDeclaration: - return n.data.(*FunctionDeclaration).ForEachChild(v) + return (*FunctionDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindClassDeclaration: - return n.data.(*ClassDeclaration).ForEachChild(v) + return (*ClassDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindClassExpression: - return n.data.(*ClassExpression).ForEachChild(v) + return (*ClassExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindHeritageClause: - return n.data.(*HeritageClause).ForEachChild(v) + return (*HeritageClause)(unsafe.Pointer(n)).ForEachChild(v) case KindInterfaceDeclaration: - return n.data.(*InterfaceDeclaration).ForEachChild(v) + return (*InterfaceDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindTypeAliasDeclaration, KindJSTypeAliasDeclaration: - return n.data.(*TypeAliasDeclaration).ForEachChild(v) + return (*TypeAliasDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindEnumMember: - return n.data.(*EnumMember).ForEachChild(v) + return (*EnumMember)(unsafe.Pointer(n)).ForEachChild(v) case KindEnumDeclaration: - return n.data.(*EnumDeclaration).ForEachChild(v) + return (*EnumDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindModuleBlock: - return n.data.(*ModuleBlock).ForEachChild(v) + return (*ModuleBlock)(unsafe.Pointer(n)).ForEachChild(v) case KindImportDeclaration, KindJSImportDeclaration: - return n.data.(*ImportDeclaration).ForEachChild(v) + return (*ImportDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindExternalModuleReference: - return n.data.(*ExternalModuleReference).ForEachChild(v) + return (*ExternalModuleReference)(unsafe.Pointer(n)).ForEachChild(v) case KindNamespaceImport: - return n.data.(*NamespaceImport).ForEachChild(v) + return (*NamespaceImport)(unsafe.Pointer(n)).ForEachChild(v) case KindNamedImports: - return n.data.(*NamedImports).ForEachChild(v) + return (*NamedImports)(unsafe.Pointer(n)).ForEachChild(v) case KindExportAssignment: - return n.data.(*ExportAssignment).ForEachChild(v) + return (*ExportAssignment)(unsafe.Pointer(n)).ForEachChild(v) case KindNamespaceExportDeclaration: - return n.data.(*NamespaceExportDeclaration).ForEachChild(v) + return (*NamespaceExportDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindNamespaceExport: - return n.data.(*NamespaceExport).ForEachChild(v) + return (*NamespaceExport)(unsafe.Pointer(n)).ForEachChild(v) case KindNamedExports: - return n.data.(*NamedExports).ForEachChild(v) + return (*NamedExports)(unsafe.Pointer(n)).ForEachChild(v) case KindExportSpecifier: - return n.data.(*ExportSpecifier).ForEachChild(v) + return (*ExportSpecifier)(unsafe.Pointer(n)).ForEachChild(v) case KindCallSignature: - return n.data.(*CallSignatureDeclaration).ForEachChild(v) + return (*CallSignatureDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindConstructSignature: - return n.data.(*ConstructSignatureDeclaration).ForEachChild(v) + return (*ConstructSignatureDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindConstructor: - return n.data.(*ConstructorDeclaration).ForEachChild(v) + return (*ConstructorDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindGetAccessor: - return n.data.(*GetAccessorDeclaration).ForEachChild(v) + return (*GetAccessorDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindSetAccessor: - return n.data.(*SetAccessorDeclaration).ForEachChild(v) + return (*SetAccessorDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindIndexSignature: - return n.data.(*IndexSignatureDeclaration).ForEachChild(v) + return (*IndexSignatureDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindMethodSignature: - return n.data.(*MethodSignatureDeclaration).ForEachChild(v) + return (*MethodSignatureDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindMethodDeclaration: - return n.data.(*MethodDeclaration).ForEachChild(v) + return (*MethodDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindPropertySignature: - return n.data.(*PropertySignatureDeclaration).ForEachChild(v) + return (*PropertySignatureDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindPropertyDeclaration: - return n.data.(*PropertyDeclaration).ForEachChild(v) + return (*PropertyDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindClassStaticBlockDeclaration: - return n.data.(*ClassStaticBlockDeclaration).ForEachChild(v) + return (*ClassStaticBlockDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindBinaryExpression: - return n.data.(*BinaryExpression).ForEachChild(v) + return (*BinaryExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindPrefixUnaryExpression: - return n.data.(*PrefixUnaryExpression).ForEachChild(v) + return (*PrefixUnaryExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindPostfixUnaryExpression: - return n.data.(*PostfixUnaryExpression).ForEachChild(v) + return (*PostfixUnaryExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindYieldExpression: - return n.data.(*YieldExpression).ForEachChild(v) + return (*YieldExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindArrowFunction: - return n.data.(*ArrowFunction).ForEachChild(v) + return (*ArrowFunction)(unsafe.Pointer(n)).ForEachChild(v) case KindFunctionExpression: - return n.data.(*FunctionExpression).ForEachChild(v) + return (*FunctionExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindAsExpression: - return n.data.(*AsExpression).ForEachChild(v) + return (*AsExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindSatisfiesExpression: - return n.data.(*SatisfiesExpression).ForEachChild(v) + return (*SatisfiesExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindConditionalExpression: - return n.data.(*ConditionalExpression).ForEachChild(v) + return (*ConditionalExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindPropertyAccessExpression: - return n.data.(*PropertyAccessExpression).ForEachChild(v) + return (*PropertyAccessExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindElementAccessExpression: - return n.data.(*ElementAccessExpression).ForEachChild(v) + return (*ElementAccessExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindCallExpression: - return n.data.(*CallExpression).ForEachChild(v) + return (*CallExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindNewExpression: - return n.data.(*NewExpression).ForEachChild(v) + return (*NewExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindMetaProperty: - return n.data.(*MetaProperty).ForEachChild(v) + return (*MetaProperty)(unsafe.Pointer(n)).ForEachChild(v) case KindNonNullExpression: - return n.data.(*NonNullExpression).ForEachChild(v) + return (*NonNullExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindSpreadElement: - return n.data.(*SpreadElement).ForEachChild(v) + return (*SpreadElement)(unsafe.Pointer(n)).ForEachChild(v) case KindTemplateExpression: - return n.data.(*TemplateExpression).ForEachChild(v) + return (*TemplateExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindTemplateSpan: - return n.data.(*TemplateSpan).ForEachChild(v) + return (*TemplateSpan)(unsafe.Pointer(n)).ForEachChild(v) case KindTaggedTemplateExpression: - return n.data.(*TaggedTemplateExpression).ForEachChild(v) + return (*TaggedTemplateExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindParenthesizedExpression: - return n.data.(*ParenthesizedExpression).ForEachChild(v) + return (*ParenthesizedExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindArrayLiteralExpression: - return n.data.(*ArrayLiteralExpression).ForEachChild(v) + return (*ArrayLiteralExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindObjectLiteralExpression: - return n.data.(*ObjectLiteralExpression).ForEachChild(v) + return (*ObjectLiteralExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindSpreadAssignment: - return n.data.(*SpreadAssignment).ForEachChild(v) + return (*SpreadAssignment)(unsafe.Pointer(n)).ForEachChild(v) case KindPropertyAssignment: - return n.data.(*PropertyAssignment).ForEachChild(v) + return (*PropertyAssignment)(unsafe.Pointer(n)).ForEachChild(v) case KindShorthandPropertyAssignment: - return n.data.(*ShorthandPropertyAssignment).ForEachChild(v) + return (*ShorthandPropertyAssignment)(unsafe.Pointer(n)).ForEachChild(v) case KindDeleteExpression: - return n.data.(*DeleteExpression).ForEachChild(v) + return (*DeleteExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindTypeOfExpression: - return n.data.(*TypeOfExpression).ForEachChild(v) + return (*TypeOfExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindVoidExpression: - return n.data.(*VoidExpression).ForEachChild(v) + return (*VoidExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindAwaitExpression: - return n.data.(*AwaitExpression).ForEachChild(v) + return (*AwaitExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindTypeAssertionExpression: - return n.data.(*TypeAssertion).ForEachChild(v) + return (*TypeAssertion)(unsafe.Pointer(n)).ForEachChild(v) case KindUnionType: - return n.data.(*UnionTypeNode).ForEachChild(v) + return (*UnionTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindIntersectionType: - return n.data.(*IntersectionTypeNode).ForEachChild(v) + return (*IntersectionTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindConditionalType: - return n.data.(*ConditionalTypeNode).ForEachChild(v) + return (*ConditionalTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindTypeOperator: - return n.data.(*TypeOperatorNode).ForEachChild(v) + return (*TypeOperatorNode)(unsafe.Pointer(n)).ForEachChild(v) case KindInferType: - return n.data.(*InferTypeNode).ForEachChild(v) + return (*InferTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindArrayType: - return n.data.(*ArrayTypeNode).ForEachChild(v) + return (*ArrayTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindIndexedAccessType: - return n.data.(*IndexedAccessTypeNode).ForEachChild(v) + return (*IndexedAccessTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindTypeReference: - return n.data.(*TypeReferenceNode).ForEachChild(v) + return (*TypeReferenceNode)(unsafe.Pointer(n)).ForEachChild(v) case KindExpressionWithTypeArguments: - return n.data.(*ExpressionWithTypeArguments).ForEachChild(v) + return (*ExpressionWithTypeArguments)(unsafe.Pointer(n)).ForEachChild(v) case KindLiteralType: - return n.data.(*LiteralTypeNode).ForEachChild(v) + return (*LiteralTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindTypePredicate: - return n.data.(*TypePredicateNode).ForEachChild(v) + return (*TypePredicateNode)(unsafe.Pointer(n)).ForEachChild(v) case KindImportAttribute: - return n.data.(*ImportAttribute).ForEachChild(v) + return (*ImportAttribute)(unsafe.Pointer(n)).ForEachChild(v) case KindImportAttributes: - return n.data.(*ImportAttributes).ForEachChild(v) + return (*ImportAttributes)(unsafe.Pointer(n)).ForEachChild(v) case KindTypeQuery: - return n.data.(*TypeQueryNode).ForEachChild(v) + return (*TypeQueryNode)(unsafe.Pointer(n)).ForEachChild(v) case KindMappedType: - return n.data.(*MappedTypeNode).ForEachChild(v) + return (*MappedTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindTypeLiteral: - return n.data.(*TypeLiteralNode).ForEachChild(v) + return (*TypeLiteralNode)(unsafe.Pointer(n)).ForEachChild(v) case KindTupleType: - return n.data.(*TupleTypeNode).ForEachChild(v) + return (*TupleTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindNamedTupleMember: - return n.data.(*NamedTupleMember).ForEachChild(v) + return (*NamedTupleMember)(unsafe.Pointer(n)).ForEachChild(v) case KindOptionalType: - return n.data.(*OptionalTypeNode).ForEachChild(v) + return (*OptionalTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindRestType: - return n.data.(*RestTypeNode).ForEachChild(v) + return (*RestTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindParenthesizedType: - return n.data.(*ParenthesizedTypeNode).ForEachChild(v) + return (*ParenthesizedTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindFunctionType: - return n.data.(*FunctionTypeNode).ForEachChild(v) + return (*FunctionTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindConstructorType: - return n.data.(*ConstructorTypeNode).ForEachChild(v) + return (*ConstructorTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindTemplateLiteralType: - return n.data.(*TemplateLiteralTypeNode).ForEachChild(v) + return (*TemplateLiteralTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindTemplateLiteralTypeSpan: - return n.data.(*TemplateLiteralTypeSpan).ForEachChild(v) + return (*TemplateLiteralTypeSpan)(unsafe.Pointer(n)).ForEachChild(v) case KindSyntheticExpression: - return n.data.(*SyntheticExpression).ForEachChild(v) + return (*SyntheticExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindPartiallyEmittedExpression: - return n.data.(*PartiallyEmittedExpression).ForEachChild(v) + return (*PartiallyEmittedExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxElement: - return n.data.(*JsxElement).ForEachChild(v) + return (*JsxElement)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxAttributes: - return n.data.(*JsxAttributes).ForEachChild(v) + return (*JsxAttributes)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxNamespacedName: - return n.data.(*JsxNamespacedName).ForEachChild(v) + return (*JsxNamespacedName)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxOpeningElement: - return n.data.(*JsxOpeningElement).ForEachChild(v) + return (*JsxOpeningElement)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxSelfClosingElement: - return n.data.(*JsxSelfClosingElement).ForEachChild(v) + return (*JsxSelfClosingElement)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxFragment: - return n.data.(*JsxFragment).ForEachChild(v) + return (*JsxFragment)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxAttribute: - return n.data.(*JsxAttribute).ForEachChild(v) + return (*JsxAttribute)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxSpreadAttribute: - return n.data.(*JsxSpreadAttribute).ForEachChild(v) + return (*JsxSpreadAttribute)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxClosingElement: - return n.data.(*JsxClosingElement).ForEachChild(v) + return (*JsxClosingElement)(unsafe.Pointer(n)).ForEachChild(v) case KindJsxExpression: - return n.data.(*JsxExpression).ForEachChild(v) + return (*JsxExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindSyntaxList: - return n.data.(*SyntaxList).ForEachChild(v) + return (*SyntaxList)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDoc: - return n.data.(*JSDoc).ForEachChild(v) + return (*JSDoc)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocTypeExpression: - return n.data.(*JSDocTypeExpression).ForEachChild(v) + return (*JSDocTypeExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocNonNullableType: - return n.data.(*JSDocNonNullableType).ForEachChild(v) + return (*JSDocNonNullableType)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocNullableType: - return n.data.(*JSDocNullableType).ForEachChild(v) + return (*JSDocNullableType)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocVariadicType: - return n.data.(*JSDocVariadicType).ForEachChild(v) + return (*JSDocVariadicType)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocOptionalType: - return n.data.(*JSDocOptionalType).ForEachChild(v) + return (*JSDocOptionalType)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocTypeTag: - return n.data.(*JSDocTypeTag).ForEachChild(v) + return (*JSDocTypeTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocUnknownTag: - return n.data.(*JSDocUnknownTag).ForEachChild(v) + return (*JSDocUnknownTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocTemplateTag: - return n.data.(*JSDocTemplateTag).ForEachChild(v) + return (*JSDocTemplateTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocReturnTag: - return n.data.(*JSDocReturnTag).ForEachChild(v) + return (*JSDocReturnTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocPublicTag: - return n.data.(*JSDocPublicTag).ForEachChild(v) + return (*JSDocPublicTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocPrivateTag: - return n.data.(*JSDocPrivateTag).ForEachChild(v) + return (*JSDocPrivateTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocProtectedTag: - return n.data.(*JSDocProtectedTag).ForEachChild(v) + return (*JSDocProtectedTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocReadonlyTag: - return n.data.(*JSDocReadonlyTag).ForEachChild(v) + return (*JSDocReadonlyTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocOverrideTag: - return n.data.(*JSDocOverrideTag).ForEachChild(v) + return (*JSDocOverrideTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocDeprecatedTag: - return n.data.(*JSDocDeprecatedTag).ForEachChild(v) + return (*JSDocDeprecatedTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocSeeTag: - return n.data.(*JSDocSeeTag).ForEachChild(v) + return (*JSDocSeeTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocImplementsTag: - return n.data.(*JSDocImplementsTag).ForEachChild(v) + return (*JSDocImplementsTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocAugmentsTag: - return n.data.(*JSDocAugmentsTag).ForEachChild(v) + return (*JSDocAugmentsTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocSatisfiesTag: - return n.data.(*JSDocSatisfiesTag).ForEachChild(v) + return (*JSDocSatisfiesTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocThrowsTag: - return n.data.(*JSDocThrowsTag).ForEachChild(v) + return (*JSDocThrowsTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocThisTag: - return n.data.(*JSDocThisTag).ForEachChild(v) + return (*JSDocThisTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocImportTag: - return n.data.(*JSDocImportTag).ForEachChild(v) + return (*JSDocImportTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocCallbackTag: - return n.data.(*JSDocCallbackTag).ForEachChild(v) + return (*JSDocCallbackTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocOverloadTag: - return n.data.(*JSDocOverloadTag).ForEachChild(v) + return (*JSDocOverloadTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocTypedefTag: - return n.data.(*JSDocTypedefTag).ForEachChild(v) + return (*JSDocTypedefTag)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocSignature: - return n.data.(*JSDocSignature).ForEachChild(v) + return (*JSDocSignature)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocNameReference: - return n.data.(*JSDocNameReference).ForEachChild(v) + return (*JSDocNameReference)(unsafe.Pointer(n)).ForEachChild(v) case KindSourceFile: - return n.data.(*SourceFile).ForEachChild(v) + return (*SourceFile)(unsafe.Pointer(n)).ForEachChild(v) case KindModuleDeclaration: - return n.data.(*ModuleDeclaration).ForEachChild(v) + return (*ModuleDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindImportEqualsDeclaration: - return n.data.(*ImportEqualsDeclaration).ForEachChild(v) + return (*ImportEqualsDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindExportDeclaration: - return n.data.(*ExportDeclaration).ForEachChild(v) + return (*ExportDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindImportType: - return n.data.(*ImportTypeNode).ForEachChild(v) + return (*ImportTypeNode)(unsafe.Pointer(n)).ForEachChild(v) case KindImportClause: - return n.data.(*ImportClause).ForEachChild(v) + return (*ImportClause)(unsafe.Pointer(n)).ForEachChild(v) case KindImportSpecifier: - return n.data.(*ImportSpecifier).ForEachChild(v) + return (*ImportSpecifier)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocLink: - return n.data.(*JSDocLink).ForEachChild(v) + return (*JSDocLink)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocLinkPlain: - return n.data.(*JSDocLinkPlain).ForEachChild(v) + return (*JSDocLinkPlain)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocLinkCode: - return n.data.(*JSDocLinkCode).ForEachChild(v) + return (*JSDocLinkCode)(unsafe.Pointer(n)).ForEachChild(v) case KindTypeParameter: - return n.data.(*TypeParameterDeclaration).ForEachChild(v) + return (*TypeParameterDeclaration)(unsafe.Pointer(n)).ForEachChild(v) case KindSyntheticReferenceExpression: - return n.data.(*SyntheticReferenceExpression).ForEachChild(v) + return (*SyntheticReferenceExpression)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocTypeLiteral: - return n.data.(*JSDocTypeLiteral).ForEachChild(v) + return (*JSDocTypeLiteral)(unsafe.Pointer(n)).ForEachChild(v) case KindJSDocParameterTag, KindJSDocPropertyTag: - return n.data.(*JSDocParameterOrPropertyTag).ForEachChild(v) + return (*JSDocParameterOrPropertyTag)(unsafe.Pointer(n)).ForEachChild(v) default: return false } } // ────────────────────────────────────────────────────────────────────── -// As*() cast methods +// VisitEachChild dispatch // ────────────────────────────────────────────────────────────────────── -func (n *Node) AsToken() *Token { - return n.data.(*Token) -} - -func (n *Node) AsIdentifier() *Identifier { - return n.data.(*Identifier) -} - -func (n *Node) AsPrivateIdentifier() *PrivateIdentifier { - return n.data.(*PrivateIdentifier) -} - -func (n *Node) AsQualifiedName() *QualifiedName { - return n.data.(*QualifiedName) -} - -func (n *Node) AsComputedPropertyName() *ComputedPropertyName { - return n.data.(*ComputedPropertyName) -} - -func (n *Node) AsDecorator() *Decorator { - return n.data.(*Decorator) -} - -func (n *Node) AsEmptyStatement() *EmptyStatement { - return n.data.(*EmptyStatement) -} - -func (n *Node) AsIfStatement() *IfStatement { - return n.data.(*IfStatement) -} - -func (n *Node) AsDoStatement() *DoStatement { - return n.data.(*DoStatement) -} - -func (n *Node) AsWhileStatement() *WhileStatement { - return n.data.(*WhileStatement) -} - -func (n *Node) AsForStatement() *ForStatement { - return n.data.(*ForStatement) -} - -func (n *Node) AsForInOrOfStatement() *ForInOrOfStatement { - return n.data.(*ForInOrOfStatement) -} - -func (n *Node) AsBreakStatement() *BreakStatement { - return n.data.(*BreakStatement) -} - -func (n *Node) AsContinueStatement() *ContinueStatement { - return n.data.(*ContinueStatement) -} - -func (n *Node) AsReturnStatement() *ReturnStatement { - return n.data.(*ReturnStatement) -} - -func (n *Node) AsWithStatement() *WithStatement { - return n.data.(*WithStatement) -} - -func (n *Node) AsSwitchStatement() *SwitchStatement { - return n.data.(*SwitchStatement) -} - -func (n *Node) AsCaseBlock() *CaseBlock { - return n.data.(*CaseBlock) -} - -func (n *Node) AsCaseOrDefaultClause() *CaseOrDefaultClause { - return n.data.(*CaseOrDefaultClause) -} - -func (n *Node) AsThrowStatement() *ThrowStatement { - return n.data.(*ThrowStatement) -} - -func (n *Node) AsTryStatement() *TryStatement { - return n.data.(*TryStatement) -} - -func (n *Node) AsCatchClause() *CatchClause { - return n.data.(*CatchClause) -} - -func (n *Node) AsDebuggerStatement() *DebuggerStatement { - return n.data.(*DebuggerStatement) -} - -func (n *Node) AsLabeledStatement() *LabeledStatement { - return n.data.(*LabeledStatement) -} - -func (n *Node) AsExpressionStatement() *ExpressionStatement { - return n.data.(*ExpressionStatement) -} - -func (n *Node) AsBlock() *Block { - return n.data.(*Block) +func (n *Node) VisitEachChild(v *NodeVisitor) *Node { + switch n.Kind { + case KindQualifiedName: + return (*QualifiedName)(unsafe.Pointer(n)).VisitEachChild(v) + case KindComputedPropertyName: + return (*ComputedPropertyName)(unsafe.Pointer(n)).VisitEachChild(v) + case KindDecorator: + return (*Decorator)(unsafe.Pointer(n)).VisitEachChild(v) + case KindIfStatement: + return (*IfStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindDoStatement: + return (*DoStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindWhileStatement: + return (*WhileStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindForStatement: + return (*ForStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindForInStatement, KindForOfStatement: + return (*ForInOrOfStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindBreakStatement: + return (*BreakStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindContinueStatement: + return (*ContinueStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindReturnStatement: + return (*ReturnStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindWithStatement: + return (*WithStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindSwitchStatement: + return (*SwitchStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindCaseBlock: + return (*CaseBlock)(unsafe.Pointer(n)).VisitEachChild(v) + case KindCaseClause, KindDefaultClause: + return (*CaseOrDefaultClause)(unsafe.Pointer(n)).VisitEachChild(v) + case KindThrowStatement: + return (*ThrowStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTryStatement: + return (*TryStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindCatchClause: + return (*CatchClause)(unsafe.Pointer(n)).VisitEachChild(v) + case KindLabeledStatement: + return (*LabeledStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindExpressionStatement: + return (*ExpressionStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindBlock: + return (*Block)(unsafe.Pointer(n)).VisitEachChild(v) + case KindVariableStatement: + return (*VariableStatement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindVariableDeclaration: + return (*VariableDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindVariableDeclarationList: + return (*VariableDeclarationList)(unsafe.Pointer(n)).VisitEachChild(v) + case KindObjectBindingPattern, KindArrayBindingPattern: + return (*BindingPattern)(unsafe.Pointer(n)).VisitEachChild(v) + case KindParameter: + return (*ParameterDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindBindingElement: + return (*BindingElement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindMissingDeclaration: + return (*MissingDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindFunctionDeclaration: + return (*FunctionDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindClassDeclaration: + return (*ClassDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindClassExpression: + return (*ClassExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindHeritageClause: + return (*HeritageClause)(unsafe.Pointer(n)).VisitEachChild(v) + case KindInterfaceDeclaration: + return (*InterfaceDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTypeAliasDeclaration, KindJSTypeAliasDeclaration: + return (*TypeAliasDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindEnumMember: + return (*EnumMember)(unsafe.Pointer(n)).VisitEachChild(v) + case KindEnumDeclaration: + return (*EnumDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindModuleBlock: + return (*ModuleBlock)(unsafe.Pointer(n)).VisitEachChild(v) + case KindImportDeclaration, KindJSImportDeclaration: + return (*ImportDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindExternalModuleReference: + return (*ExternalModuleReference)(unsafe.Pointer(n)).VisitEachChild(v) + case KindNamespaceImport: + return (*NamespaceImport)(unsafe.Pointer(n)).VisitEachChild(v) + case KindNamedImports: + return (*NamedImports)(unsafe.Pointer(n)).VisitEachChild(v) + case KindExportAssignment: + return (*ExportAssignment)(unsafe.Pointer(n)).VisitEachChild(v) + case KindNamespaceExportDeclaration: + return (*NamespaceExportDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindNamespaceExport: + return (*NamespaceExport)(unsafe.Pointer(n)).VisitEachChild(v) + case KindNamedExports: + return (*NamedExports)(unsafe.Pointer(n)).VisitEachChild(v) + case KindExportSpecifier: + return (*ExportSpecifier)(unsafe.Pointer(n)).VisitEachChild(v) + case KindCallSignature: + return (*CallSignatureDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindConstructSignature: + return (*ConstructSignatureDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindConstructor: + return (*ConstructorDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindGetAccessor: + return (*GetAccessorDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindSetAccessor: + return (*SetAccessorDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindIndexSignature: + return (*IndexSignatureDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindMethodSignature: + return (*MethodSignatureDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindMethodDeclaration: + return (*MethodDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindPropertySignature: + return (*PropertySignatureDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindPropertyDeclaration: + return (*PropertyDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindClassStaticBlockDeclaration: + return (*ClassStaticBlockDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindBinaryExpression: + return (*BinaryExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindPrefixUnaryExpression: + return (*PrefixUnaryExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindPostfixUnaryExpression: + return (*PostfixUnaryExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindYieldExpression: + return (*YieldExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindArrowFunction: + return (*ArrowFunction)(unsafe.Pointer(n)).VisitEachChild(v) + case KindFunctionExpression: + return (*FunctionExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindAsExpression: + return (*AsExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindSatisfiesExpression: + return (*SatisfiesExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindConditionalExpression: + return (*ConditionalExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindPropertyAccessExpression: + return (*PropertyAccessExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindElementAccessExpression: + return (*ElementAccessExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindCallExpression: + return (*CallExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindNewExpression: + return (*NewExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindMetaProperty: + return (*MetaProperty)(unsafe.Pointer(n)).VisitEachChild(v) + case KindNonNullExpression: + return (*NonNullExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindSpreadElement: + return (*SpreadElement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTemplateExpression: + return (*TemplateExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTemplateSpan: + return (*TemplateSpan)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTaggedTemplateExpression: + return (*TaggedTemplateExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindParenthesizedExpression: + return (*ParenthesizedExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindArrayLiteralExpression: + return (*ArrayLiteralExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindObjectLiteralExpression: + return (*ObjectLiteralExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindSpreadAssignment: + return (*SpreadAssignment)(unsafe.Pointer(n)).VisitEachChild(v) + case KindPropertyAssignment: + return (*PropertyAssignment)(unsafe.Pointer(n)).VisitEachChild(v) + case KindShorthandPropertyAssignment: + return (*ShorthandPropertyAssignment)(unsafe.Pointer(n)).VisitEachChild(v) + case KindDeleteExpression: + return (*DeleteExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTypeOfExpression: + return (*TypeOfExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindVoidExpression: + return (*VoidExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindAwaitExpression: + return (*AwaitExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTypeAssertionExpression: + return (*TypeAssertion)(unsafe.Pointer(n)).VisitEachChild(v) + case KindUnionType: + return (*UnionTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindIntersectionType: + return (*IntersectionTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindConditionalType: + return (*ConditionalTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTypeOperator: + return (*TypeOperatorNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindInferType: + return (*InferTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindArrayType: + return (*ArrayTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindIndexedAccessType: + return (*IndexedAccessTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTypeReference: + return (*TypeReferenceNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindExpressionWithTypeArguments: + return (*ExpressionWithTypeArguments)(unsafe.Pointer(n)).VisitEachChild(v) + case KindLiteralType: + return (*LiteralTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTypePredicate: + return (*TypePredicateNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindImportAttribute: + return (*ImportAttribute)(unsafe.Pointer(n)).VisitEachChild(v) + case KindImportAttributes: + return (*ImportAttributes)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTypeQuery: + return (*TypeQueryNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindMappedType: + return (*MappedTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTypeLiteral: + return (*TypeLiteralNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTupleType: + return (*TupleTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindNamedTupleMember: + return (*NamedTupleMember)(unsafe.Pointer(n)).VisitEachChild(v) + case KindOptionalType: + return (*OptionalTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindRestType: + return (*RestTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindParenthesizedType: + return (*ParenthesizedTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindFunctionType: + return (*FunctionTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindConstructorType: + return (*ConstructorTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTemplateLiteralType: + return (*TemplateLiteralTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTemplateLiteralTypeSpan: + return (*TemplateLiteralTypeSpan)(unsafe.Pointer(n)).VisitEachChild(v) + case KindSyntheticExpression: + return (*SyntheticExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindPartiallyEmittedExpression: + return (*PartiallyEmittedExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxElement: + return (*JsxElement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxAttributes: + return (*JsxAttributes)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxNamespacedName: + return (*JsxNamespacedName)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxOpeningElement: + return (*JsxOpeningElement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxSelfClosingElement: + return (*JsxSelfClosingElement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxFragment: + return (*JsxFragment)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxAttribute: + return (*JsxAttribute)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxSpreadAttribute: + return (*JsxSpreadAttribute)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxClosingElement: + return (*JsxClosingElement)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJsxExpression: + return (*JsxExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindSyntaxList: + return (*SyntaxList)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDoc: + return (*JSDoc)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocTypeExpression: + return (*JSDocTypeExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocNonNullableType: + return (*JSDocNonNullableType)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocNullableType: + return (*JSDocNullableType)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocVariadicType: + return (*JSDocVariadicType)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocOptionalType: + return (*JSDocOptionalType)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocTypeTag: + return (*JSDocTypeTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocUnknownTag: + return (*JSDocUnknownTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocTemplateTag: + return (*JSDocTemplateTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocReturnTag: + return (*JSDocReturnTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocPublicTag: + return (*JSDocPublicTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocPrivateTag: + return (*JSDocPrivateTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocProtectedTag: + return (*JSDocProtectedTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocReadonlyTag: + return (*JSDocReadonlyTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocOverrideTag: + return (*JSDocOverrideTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocDeprecatedTag: + return (*JSDocDeprecatedTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocSeeTag: + return (*JSDocSeeTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocImplementsTag: + return (*JSDocImplementsTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocAugmentsTag: + return (*JSDocAugmentsTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocSatisfiesTag: + return (*JSDocSatisfiesTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocThrowsTag: + return (*JSDocThrowsTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocThisTag: + return (*JSDocThisTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocImportTag: + return (*JSDocImportTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocCallbackTag: + return (*JSDocCallbackTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocOverloadTag: + return (*JSDocOverloadTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocTypedefTag: + return (*JSDocTypedefTag)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocSignature: + return (*JSDocSignature)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocNameReference: + return (*JSDocNameReference)(unsafe.Pointer(n)).VisitEachChild(v) + case KindSourceFile: + return (*SourceFile)(unsafe.Pointer(n)).VisitEachChild(v) + case KindModuleDeclaration: + return (*ModuleDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindImportEqualsDeclaration: + return (*ImportEqualsDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindExportDeclaration: + return (*ExportDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindImportType: + return (*ImportTypeNode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindImportClause: + return (*ImportClause)(unsafe.Pointer(n)).VisitEachChild(v) + case KindImportSpecifier: + return (*ImportSpecifier)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocLink: + return (*JSDocLink)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocLinkPlain: + return (*JSDocLinkPlain)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocLinkCode: + return (*JSDocLinkCode)(unsafe.Pointer(n)).VisitEachChild(v) + case KindTypeParameter: + return (*TypeParameterDeclaration)(unsafe.Pointer(n)).VisitEachChild(v) + case KindSyntheticReferenceExpression: + return (*SyntheticReferenceExpression)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocTypeLiteral: + return (*JSDocTypeLiteral)(unsafe.Pointer(n)).VisitEachChild(v) + case KindJSDocParameterTag, KindJSDocPropertyTag: + return (*JSDocParameterOrPropertyTag)(unsafe.Pointer(n)).VisitEachChild(v) + default: + return n + } } -func (n *Node) AsVariableStatement() *VariableStatement { - return n.data.(*VariableStatement) -} +// ────────────────────────────────────────────────────────────────────── +// SubtreeFacts dispatch +// ────────────────────────────────────────────────────────────────────── -func (n *Node) AsVariableDeclaration() *VariableDeclaration { - return n.data.(*VariableDeclaration) -} +func (n *Node) SubtreeFacts() SubtreeFacts { + switch n.Kind { + case kindFlowSwitchClauseData: + return SubtreeFactsNone + case kindFlowReduceLabelData: + return SubtreeFactsNone + case KindUnknown, KindEndOfFile, KindSingleLineCommentTrivia, KindMultiLineCommentTrivia, KindNewLineTrivia, KindWhitespaceTrivia, KindConflictMarkerTrivia, KindNonTextFileMarkerTrivia, KindJsxTextAllWhiteSpaces, KindOpenBraceToken, KindCloseBraceToken, KindOpenParenToken, KindCloseParenToken, KindOpenBracketToken, KindCloseBracketToken, KindDotToken, KindDotDotDotToken, KindSemicolonToken, KindCommaToken, KindQuestionDotToken, KindLessThanToken, KindLessThanSlashToken, KindGreaterThanToken, KindLessThanEqualsToken, KindGreaterThanEqualsToken, KindEqualsEqualsToken, KindExclamationEqualsToken, KindEqualsEqualsEqualsToken, KindExclamationEqualsEqualsToken, KindEqualsGreaterThanToken, KindPlusToken, KindMinusToken, KindAsteriskToken, KindAsteriskAsteriskToken, KindSlashToken, KindPercentToken, KindPlusPlusToken, KindMinusMinusToken, KindLessThanLessThanToken, KindGreaterThanGreaterThanToken, KindGreaterThanGreaterThanGreaterThanToken, KindAmpersandToken, KindBarToken, KindCaretToken, KindExclamationToken, KindTildeToken, KindAmpersandAmpersandToken, KindBarBarToken, KindQuestionToken, KindColonToken, KindAtToken, KindQuestionQuestionToken, KindBacktickToken, KindHashToken, KindEqualsToken, KindPlusEqualsToken, KindMinusEqualsToken, KindAsteriskEqualsToken, KindAsteriskAsteriskEqualsToken, KindSlashEqualsToken, KindPercentEqualsToken, KindLessThanLessThanEqualsToken, KindGreaterThanGreaterThanEqualsToken, KindGreaterThanGreaterThanGreaterThanEqualsToken, KindAmpersandEqualsToken, KindBarEqualsToken, KindBarBarEqualsToken, KindAmpersandAmpersandEqualsToken, KindQuestionQuestionEqualsToken, KindCaretEqualsToken, KindJSDocCommentTextToken, KindBreakKeyword, KindCaseKeyword, KindCatchKeyword, KindClassKeyword, KindConstKeyword, KindContinueKeyword, KindDebuggerKeyword, KindDefaultKeyword, KindDeleteKeyword, KindDoKeyword, KindElseKeyword, KindEnumKeyword, KindExportKeyword, KindExtendsKeyword, KindFinallyKeyword, KindForKeyword, KindFunctionKeyword, KindIfKeyword, KindInKeyword, KindInstanceOfKeyword, KindNewKeyword, KindReturnKeyword, KindSwitchKeyword, KindThrowKeyword, KindTryKeyword, KindTypeOfKeyword, KindVarKeyword, KindWhileKeyword, KindWithKeyword, KindImplementsKeyword, KindInterfaceKeyword, KindLetKeyword, KindPackageKeyword, KindPrivateKeyword, KindProtectedKeyword, KindPublicKeyword, KindStaticKeyword, KindYieldKeyword, KindAbstractKeyword, KindAccessorKeyword, KindAsKeyword, KindAssertsKeyword, KindAssertKeyword, KindAsyncKeyword, KindAwaitKeyword, KindConstructorKeyword, KindDeclareKeyword, KindGetKeyword, KindImmediateKeyword, KindInferKeyword, KindIsKeyword, KindKeyOfKeyword, KindModuleKeyword, KindNamespaceKeyword, KindOutKeyword, KindReadonlyKeyword, KindRequireKeyword, KindSatisfiesKeyword, KindSetKeyword, KindTypeKeyword, KindUniqueKeyword, KindUsingKeyword, KindFromKeyword, KindGlobalKeyword, KindOverrideKeyword, KindOfKeyword, KindDeferKeyword: + return (*Token)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNumericLiteral: + return (*NumericLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindBigIntLiteral: + return (*BigIntLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindStringLiteral: + return (*StringLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxText: + return (*JsxText)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindRegularExpressionLiteral: + return (*RegularExpressionLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNoSubstitutionTemplateLiteral: + return (*NoSubstitutionTemplateLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateHead: + return (*TemplateHead)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateMiddle: + return (*TemplateMiddle)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateTail: + return (*TemplateTail)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindIdentifier: + return (*Identifier)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPrivateIdentifier: + return (*PrivateIdentifier)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindFalseKeyword, KindImportKeyword, KindNullKeyword, KindSuperKeyword, KindThisKeyword, KindTrueKeyword: + return (*KeywordExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindVoidKeyword, KindAnyKeyword, KindBooleanKeyword, KindIntrinsicKeyword, KindNeverKeyword, KindNumberKeyword, KindObjectKeyword, KindStringKeyword, KindSymbolKeyword, KindUndefinedKeyword, KindUnknownKeyword, KindBigIntKeyword: + return (*KeywordTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindQualifiedName: + data := (*QualifiedName)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindComputedPropertyName: + data := (*ComputedPropertyName)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindDecorator: + data := (*Decorator)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindEmptyStatement: + return (*EmptyStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindIfStatement: + data := (*IfStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindDoStatement: + data := (*DoStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindWhileStatement: + data := (*WhileStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindForStatement: + data := (*ForStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindForInStatement, KindForOfStatement: + data := (*ForInOrOfStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindBreakStatement: + return (*BreakStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindContinueStatement: + return (*ContinueStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindReturnStatement: + data := (*ReturnStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindWithStatement: + data := (*WithStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindSwitchStatement: + data := (*SwitchStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindCaseBlock: + data := (*CaseBlock)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindCaseClause, KindDefaultClause: + data := (*CaseOrDefaultClause)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindThrowStatement: + data := (*ThrowStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindTryStatement: + data := (*TryStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindCatchClause: + data := (*CatchClause)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindDebuggerStatement: + return (*DebuggerStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindLabeledStatement: + return (*LabeledStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindExpressionStatement: + return (*ExpressionStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindBlock: + data := (*Block)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindVariableStatement: + data := (*VariableStatement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindVariableDeclaration: + data := (*VariableDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindVariableDeclarationList: + data := (*VariableDeclarationList)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindObjectBindingPattern, KindArrayBindingPattern: + data := (*BindingPattern)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindParameter: + data := (*ParameterDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindBindingElement: + data := (*BindingElement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindMissingDeclaration: + return (*MissingDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindFunctionDeclaration: + data := (*FunctionDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindClassDeclaration: + data := (*ClassDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindClassExpression: + data := (*ClassExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindHeritageClause: + data := (*HeritageClause)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindInterfaceDeclaration: + return (*InterfaceDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeAliasDeclaration, KindJSTypeAliasDeclaration: + return (*TypeAliasDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindEnumMember: + data := (*EnumMember)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindEnumDeclaration: + data := (*EnumDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindModuleBlock: + data := (*ModuleBlock)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindNotEmittedStatement: + return (*NotEmittedStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNotEmittedTypeElement: + return (*NotEmittedTypeElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportDeclaration, KindJSImportDeclaration: + data := (*ImportDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindExternalModuleReference: + return (*ExternalModuleReference)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamespaceImport: + return (*NamespaceImport)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamedImports: + data := (*NamedImports)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindExportAssignment: + data := (*ExportAssignment)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindNamespaceExportDeclaration: + return (*NamespaceExportDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamespaceExport: + return (*NamespaceExport)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamedExports: + data := (*NamedExports)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindExportSpecifier: + data := (*ExportSpecifier)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindCallSignature: + return (*CallSignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConstructSignature: + return (*ConstructSignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConstructor: + data := (*ConstructorDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindGetAccessor: + data := (*GetAccessorDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindSetAccessor: + data := (*SetAccessorDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindIndexSignature: + return (*IndexSignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindMethodSignature: + return (*MethodSignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindMethodDeclaration: + data := (*MethodDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindPropertySignature: + return (*PropertySignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPropertyDeclaration: + data := (*PropertyDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindSemicolonClassElement: + return (*SemicolonClassElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindClassStaticBlockDeclaration: + data := (*ClassStaticBlockDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindOmittedExpression: + return (*OmittedExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindBinaryExpression: + data := (*BinaryExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindPrefixUnaryExpression: + return (*PrefixUnaryExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPostfixUnaryExpression: + return (*PostfixUnaryExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindYieldExpression: + return (*YieldExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindArrowFunction: + data := (*ArrowFunction)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindFunctionExpression: + data := (*FunctionExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindAsExpression: + return (*AsExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSatisfiesExpression: + return (*SatisfiesExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConditionalExpression: + data := (*ConditionalExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindPropertyAccessExpression: + data := (*PropertyAccessExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindElementAccessExpression: + data := (*ElementAccessExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindCallExpression: + data := (*CallExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindNewExpression: + data := (*NewExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindMetaProperty: + data := (*MetaProperty)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindNonNullExpression: + return (*NonNullExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSpreadElement: + return (*SpreadElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateExpression: + data := (*TemplateExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindTemplateSpan: + return (*TemplateSpan)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTaggedTemplateExpression: + data := (*TaggedTemplateExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindParenthesizedExpression: + return (*ParenthesizedExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindArrayLiteralExpression: + data := (*ArrayLiteralExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindObjectLiteralExpression: + data := (*ObjectLiteralExpression)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindSpreadAssignment: + return (*SpreadAssignment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPropertyAssignment: + data := (*PropertyAssignment)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindShorthandPropertyAssignment: + data := (*ShorthandPropertyAssignment)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindDeleteExpression: + return (*DeleteExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeOfExpression: + return (*TypeOfExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindVoidExpression: + return (*VoidExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindAwaitExpression: + return (*AwaitExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeAssertionExpression: + return (*TypeAssertion)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindUnionType: + return (*UnionTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindIntersectionType: + return (*IntersectionTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConditionalType: + return (*ConditionalTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeOperator: + return (*TypeOperatorNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindInferType: + return (*InferTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindArrayType: + return (*ArrayTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindIndexedAccessType: + return (*IndexedAccessTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeReference: + return (*TypeReferenceNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindExpressionWithTypeArguments: + data := (*ExpressionWithTypeArguments)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindLiteralType: + return (*LiteralTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindThisType: + return (*ThisTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypePredicate: + return (*TypePredicateNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportAttribute: + data := (*ImportAttribute)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindImportAttributes: + data := (*ImportAttributes)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindTypeQuery: + return (*TypeQueryNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindMappedType: + return (*MappedTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeLiteral: + return (*TypeLiteralNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTupleType: + return (*TupleTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamedTupleMember: + return (*NamedTupleMember)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindOptionalType: + return (*OptionalTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindRestType: + return (*RestTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindParenthesizedType: + return (*ParenthesizedTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindFunctionType: + return (*FunctionTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConstructorType: + return (*ConstructorTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateLiteralType: + return (*TemplateLiteralTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateLiteralTypeSpan: + return (*TemplateLiteralTypeSpan)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSyntheticExpression: + return (*SyntheticExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPartiallyEmittedExpression: + return (*PartiallyEmittedExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxElement: + data := (*JsxElement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindJsxAttributes: + data := (*JsxAttributes)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindJsxNamespacedName: + data := (*JsxNamespacedName)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindJsxOpeningElement: + data := (*JsxOpeningElement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindJsxSelfClosingElement: + data := (*JsxSelfClosingElement)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindJsxFragment: + data := (*JsxFragment)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindJsxOpeningFragment: + return (*JsxOpeningFragment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxClosingFragment: + return (*JsxClosingFragment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxAttribute: + data := (*JsxAttribute)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindJsxSpreadAttribute: + return (*JsxSpreadAttribute)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxClosingElement: + return (*JsxClosingElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxExpression: + return (*JsxExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSyntaxList: + return (*SyntaxList)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDoc: + return (*JSDoc)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTypeExpression: + return (*JSDocTypeExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocNonNullableType: + return (*JSDocNonNullableType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocNullableType: + return (*JSDocNullableType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocAllType: + return (*JSDocAllType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocVariadicType: + return (*JSDocVariadicType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocOptionalType: + return (*JSDocOptionalType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTypeTag: + return (*JSDocTypeTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocUnknownTag: + return (*JSDocUnknownTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTemplateTag: + return (*JSDocTemplateTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocReturnTag: + return (*JSDocReturnTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocPublicTag: + return (*JSDocPublicTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocPrivateTag: + return (*JSDocPrivateTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocProtectedTag: + return (*JSDocProtectedTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocReadonlyTag: + return (*JSDocReadonlyTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocOverrideTag: + return (*JSDocOverrideTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocDeprecatedTag: + return (*JSDocDeprecatedTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocSeeTag: + return (*JSDocSeeTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocImplementsTag: + return (*JSDocImplementsTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocAugmentsTag: + return (*JSDocAugmentsTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocSatisfiesTag: + return (*JSDocSatisfiesTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocThrowsTag: + return (*JSDocThrowsTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocThisTag: + return (*JSDocThisTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocImportTag: + return (*JSDocImportTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocCallbackTag: + return (*JSDocCallbackTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocOverloadTag: + return (*JSDocOverloadTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTypedefTag: + return (*JSDocTypedefTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocSignature: + return (*JSDocSignature)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocNameReference: + return (*JSDocNameReference)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSourceFile: + data := (*SourceFile)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindModuleDeclaration: + data := (*ModuleDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindImportEqualsDeclaration: + data := (*ImportEqualsDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindExportDeclaration: + data := (*ExportDeclaration)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindImportType: + return (*ImportTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportClause: + data := (*ImportClause)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindImportSpecifier: + data := (*ImportSpecifier)(unsafe.Pointer(n)) + return data.subtreeFactsWorker(data.AsNode()) + case KindJSDocText: + return (*JSDocText)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocLink: + return (*JSDocLink)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocLinkPlain: + return (*JSDocLinkPlain)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocLinkCode: + return (*JSDocLinkCode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeParameter: + return (*TypeParameterDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSyntheticReferenceExpression: + return (*SyntheticReferenceExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTypeLiteral: + return (*JSDocTypeLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocParameterTag, KindJSDocPropertyTag: + return (*JSDocParameterOrPropertyTag)(unsafe.Pointer(n)).computeSubtreeFacts() + default: + panic("Unhandled case in Node.SubtreeFacts: " + n.Kind.String()) + } +} + +// ────────────────────────────────────────────────────────────────────── +// Compute subtree facts dispatch +// ────────────────────────────────────────────────────────────────────── + +func (n *Node) computeSubtreeFacts() SubtreeFacts { + switch n.Kind { + case KindUnknown, KindEndOfFile, KindSingleLineCommentTrivia, KindMultiLineCommentTrivia, KindNewLineTrivia, KindWhitespaceTrivia, KindConflictMarkerTrivia, KindNonTextFileMarkerTrivia, KindJsxTextAllWhiteSpaces, KindOpenBraceToken, KindCloseBraceToken, KindOpenParenToken, KindCloseParenToken, KindOpenBracketToken, KindCloseBracketToken, KindDotToken, KindDotDotDotToken, KindSemicolonToken, KindCommaToken, KindQuestionDotToken, KindLessThanToken, KindLessThanSlashToken, KindGreaterThanToken, KindLessThanEqualsToken, KindGreaterThanEqualsToken, KindEqualsEqualsToken, KindExclamationEqualsToken, KindEqualsEqualsEqualsToken, KindExclamationEqualsEqualsToken, KindEqualsGreaterThanToken, KindPlusToken, KindMinusToken, KindAsteriskToken, KindAsteriskAsteriskToken, KindSlashToken, KindPercentToken, KindPlusPlusToken, KindMinusMinusToken, KindLessThanLessThanToken, KindGreaterThanGreaterThanToken, KindGreaterThanGreaterThanGreaterThanToken, KindAmpersandToken, KindBarToken, KindCaretToken, KindExclamationToken, KindTildeToken, KindAmpersandAmpersandToken, KindBarBarToken, KindQuestionToken, KindColonToken, KindAtToken, KindQuestionQuestionToken, KindBacktickToken, KindHashToken, KindEqualsToken, KindPlusEqualsToken, KindMinusEqualsToken, KindAsteriskEqualsToken, KindAsteriskAsteriskEqualsToken, KindSlashEqualsToken, KindPercentEqualsToken, KindLessThanLessThanEqualsToken, KindGreaterThanGreaterThanEqualsToken, KindGreaterThanGreaterThanGreaterThanEqualsToken, KindAmpersandEqualsToken, KindBarEqualsToken, KindBarBarEqualsToken, KindAmpersandAmpersandEqualsToken, KindQuestionQuestionEqualsToken, KindCaretEqualsToken, KindJSDocCommentTextToken, KindBreakKeyword, KindCaseKeyword, KindCatchKeyword, KindClassKeyword, KindConstKeyword, KindContinueKeyword, KindDebuggerKeyword, KindDefaultKeyword, KindDeleteKeyword, KindDoKeyword, KindElseKeyword, KindEnumKeyword, KindExportKeyword, KindExtendsKeyword, KindFinallyKeyword, KindForKeyword, KindFunctionKeyword, KindIfKeyword, KindInKeyword, KindInstanceOfKeyword, KindNewKeyword, KindReturnKeyword, KindSwitchKeyword, KindThrowKeyword, KindTryKeyword, KindTypeOfKeyword, KindVarKeyword, KindWhileKeyword, KindWithKeyword, KindImplementsKeyword, KindInterfaceKeyword, KindLetKeyword, KindPackageKeyword, KindPrivateKeyword, KindProtectedKeyword, KindPublicKeyword, KindStaticKeyword, KindYieldKeyword, KindAbstractKeyword, KindAccessorKeyword, KindAsKeyword, KindAssertsKeyword, KindAssertKeyword, KindAsyncKeyword, KindAwaitKeyword, KindConstructorKeyword, KindDeclareKeyword, KindGetKeyword, KindImmediateKeyword, KindInferKeyword, KindIsKeyword, KindKeyOfKeyword, KindModuleKeyword, KindNamespaceKeyword, KindOutKeyword, KindReadonlyKeyword, KindRequireKeyword, KindSatisfiesKeyword, KindSetKeyword, KindTypeKeyword, KindUniqueKeyword, KindUsingKeyword, KindFromKeyword, KindGlobalKeyword, KindOverrideKeyword, KindOfKeyword, KindDeferKeyword: + return (*Token)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNumericLiteral: + return (*NumericLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindBigIntLiteral: + return (*BigIntLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindStringLiteral: + return (*StringLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxText: + return (*JsxText)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindRegularExpressionLiteral: + return (*RegularExpressionLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNoSubstitutionTemplateLiteral: + return (*NoSubstitutionTemplateLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateHead: + return (*TemplateHead)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateMiddle: + return (*TemplateMiddle)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateTail: + return (*TemplateTail)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindIdentifier: + return (*Identifier)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPrivateIdentifier: + return (*PrivateIdentifier)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindFalseKeyword, KindImportKeyword, KindNullKeyword, KindSuperKeyword, KindThisKeyword, KindTrueKeyword: + return (*KeywordExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindVoidKeyword, KindAnyKeyword, KindBooleanKeyword, KindIntrinsicKeyword, KindNeverKeyword, KindNumberKeyword, KindObjectKeyword, KindStringKeyword, KindSymbolKeyword, KindUndefinedKeyword, KindUnknownKeyword, KindBigIntKeyword: + return (*KeywordTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindQualifiedName: + return (*QualifiedName)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindComputedPropertyName: + return (*ComputedPropertyName)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindDecorator: + return (*Decorator)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindEmptyStatement: + return (*EmptyStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindIfStatement: + return (*IfStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindDoStatement: + return (*DoStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindWhileStatement: + return (*WhileStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindForStatement: + return (*ForStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindForInStatement, KindForOfStatement: + return (*ForInOrOfStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindBreakStatement: + return (*BreakStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindContinueStatement: + return (*ContinueStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindReturnStatement: + return (*ReturnStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindWithStatement: + return (*WithStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSwitchStatement: + return (*SwitchStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindCaseBlock: + return (*CaseBlock)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindCaseClause, KindDefaultClause: + return (*CaseOrDefaultClause)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindThrowStatement: + return (*ThrowStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTryStatement: + return (*TryStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindCatchClause: + return (*CatchClause)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindDebuggerStatement: + return (*DebuggerStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindLabeledStatement: + return (*LabeledStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindExpressionStatement: + return (*ExpressionStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindBlock: + return (*Block)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindVariableStatement: + return (*VariableStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindVariableDeclaration: + return (*VariableDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindVariableDeclarationList: + return (*VariableDeclarationList)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindObjectBindingPattern, KindArrayBindingPattern: + return (*BindingPattern)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindParameter: + return (*ParameterDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindBindingElement: + return (*BindingElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindMissingDeclaration: + return (*MissingDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindFunctionDeclaration: + return (*FunctionDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindClassDeclaration: + return (*ClassDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindClassExpression: + return (*ClassExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindHeritageClause: + return (*HeritageClause)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindInterfaceDeclaration: + return (*InterfaceDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeAliasDeclaration, KindJSTypeAliasDeclaration: + return (*TypeAliasDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindEnumMember: + return (*EnumMember)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindEnumDeclaration: + return (*EnumDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindModuleBlock: + return (*ModuleBlock)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNotEmittedStatement: + return (*NotEmittedStatement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNotEmittedTypeElement: + return (*NotEmittedTypeElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportDeclaration, KindJSImportDeclaration: + return (*ImportDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindExternalModuleReference: + return (*ExternalModuleReference)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamespaceImport: + return (*NamespaceImport)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamedImports: + return (*NamedImports)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindExportAssignment: + return (*ExportAssignment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamespaceExportDeclaration: + return (*NamespaceExportDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamespaceExport: + return (*NamespaceExport)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamedExports: + return (*NamedExports)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindExportSpecifier: + return (*ExportSpecifier)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindCallSignature: + return (*CallSignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConstructSignature: + return (*ConstructSignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConstructor: + return (*ConstructorDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindGetAccessor: + return (*GetAccessorDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSetAccessor: + return (*SetAccessorDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindIndexSignature: + return (*IndexSignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindMethodSignature: + return (*MethodSignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindMethodDeclaration: + return (*MethodDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPropertySignature: + return (*PropertySignatureDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPropertyDeclaration: + return (*PropertyDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSemicolonClassElement: + return (*SemicolonClassElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindClassStaticBlockDeclaration: + return (*ClassStaticBlockDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindOmittedExpression: + return (*OmittedExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindBinaryExpression: + return (*BinaryExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPrefixUnaryExpression: + return (*PrefixUnaryExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPostfixUnaryExpression: + return (*PostfixUnaryExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindYieldExpression: + return (*YieldExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindArrowFunction: + return (*ArrowFunction)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindFunctionExpression: + return (*FunctionExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindAsExpression: + return (*AsExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSatisfiesExpression: + return (*SatisfiesExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConditionalExpression: + return (*ConditionalExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPropertyAccessExpression: + return (*PropertyAccessExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindElementAccessExpression: + return (*ElementAccessExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindCallExpression: + return (*CallExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNewExpression: + return (*NewExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindMetaProperty: + return (*MetaProperty)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNonNullExpression: + return (*NonNullExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSpreadElement: + return (*SpreadElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateExpression: + return (*TemplateExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateSpan: + return (*TemplateSpan)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTaggedTemplateExpression: + return (*TaggedTemplateExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindParenthesizedExpression: + return (*ParenthesizedExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindArrayLiteralExpression: + return (*ArrayLiteralExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindObjectLiteralExpression: + return (*ObjectLiteralExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSpreadAssignment: + return (*SpreadAssignment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPropertyAssignment: + return (*PropertyAssignment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindShorthandPropertyAssignment: + return (*ShorthandPropertyAssignment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindDeleteExpression: + return (*DeleteExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeOfExpression: + return (*TypeOfExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindVoidExpression: + return (*VoidExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindAwaitExpression: + return (*AwaitExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeAssertionExpression: + return (*TypeAssertion)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindUnionType: + return (*UnionTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindIntersectionType: + return (*IntersectionTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConditionalType: + return (*ConditionalTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeOperator: + return (*TypeOperatorNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindInferType: + return (*InferTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindArrayType: + return (*ArrayTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindIndexedAccessType: + return (*IndexedAccessTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeReference: + return (*TypeReferenceNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindExpressionWithTypeArguments: + return (*ExpressionWithTypeArguments)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindLiteralType: + return (*LiteralTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindThisType: + return (*ThisTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypePredicate: + return (*TypePredicateNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportAttribute: + return (*ImportAttribute)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportAttributes: + return (*ImportAttributes)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeQuery: + return (*TypeQueryNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindMappedType: + return (*MappedTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeLiteral: + return (*TypeLiteralNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTupleType: + return (*TupleTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindNamedTupleMember: + return (*NamedTupleMember)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindOptionalType: + return (*OptionalTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindRestType: + return (*RestTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindParenthesizedType: + return (*ParenthesizedTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindFunctionType: + return (*FunctionTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindConstructorType: + return (*ConstructorTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateLiteralType: + return (*TemplateLiteralTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTemplateLiteralTypeSpan: + return (*TemplateLiteralTypeSpan)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSyntheticExpression: + return (*SyntheticExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindPartiallyEmittedExpression: + return (*PartiallyEmittedExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxElement: + return (*JsxElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxAttributes: + return (*JsxAttributes)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxNamespacedName: + return (*JsxNamespacedName)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxOpeningElement: + return (*JsxOpeningElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxSelfClosingElement: + return (*JsxSelfClosingElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxFragment: + return (*JsxFragment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxOpeningFragment: + return (*JsxOpeningFragment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxClosingFragment: + return (*JsxClosingFragment)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxAttribute: + return (*JsxAttribute)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxSpreadAttribute: + return (*JsxSpreadAttribute)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxClosingElement: + return (*JsxClosingElement)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJsxExpression: + return (*JsxExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSyntaxList: + return (*SyntaxList)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDoc: + return (*JSDoc)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTypeExpression: + return (*JSDocTypeExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocNonNullableType: + return (*JSDocNonNullableType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocNullableType: + return (*JSDocNullableType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocAllType: + return (*JSDocAllType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocVariadicType: + return (*JSDocVariadicType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocOptionalType: + return (*JSDocOptionalType)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTypeTag: + return (*JSDocTypeTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocUnknownTag: + return (*JSDocUnknownTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTemplateTag: + return (*JSDocTemplateTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocReturnTag: + return (*JSDocReturnTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocPublicTag: + return (*JSDocPublicTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocPrivateTag: + return (*JSDocPrivateTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocProtectedTag: + return (*JSDocProtectedTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocReadonlyTag: + return (*JSDocReadonlyTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocOverrideTag: + return (*JSDocOverrideTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocDeprecatedTag: + return (*JSDocDeprecatedTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocSeeTag: + return (*JSDocSeeTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocImplementsTag: + return (*JSDocImplementsTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocAugmentsTag: + return (*JSDocAugmentsTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocSatisfiesTag: + return (*JSDocSatisfiesTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocThrowsTag: + return (*JSDocThrowsTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocThisTag: + return (*JSDocThisTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocImportTag: + return (*JSDocImportTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocCallbackTag: + return (*JSDocCallbackTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocOverloadTag: + return (*JSDocOverloadTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTypedefTag: + return (*JSDocTypedefTag)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocSignature: + return (*JSDocSignature)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocNameReference: + return (*JSDocNameReference)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSourceFile: + return (*SourceFile)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindModuleDeclaration: + return (*ModuleDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportEqualsDeclaration: + return (*ImportEqualsDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindExportDeclaration: + return (*ExportDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportType: + return (*ImportTypeNode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportClause: + return (*ImportClause)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindImportSpecifier: + return (*ImportSpecifier)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocText: + return (*JSDocText)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocLink: + return (*JSDocLink)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocLinkPlain: + return (*JSDocLinkPlain)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocLinkCode: + return (*JSDocLinkCode)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindTypeParameter: + return (*TypeParameterDeclaration)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindSyntheticReferenceExpression: + return (*SyntheticReferenceExpression)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocTypeLiteral: + return (*JSDocTypeLiteral)(unsafe.Pointer(n)).computeSubtreeFacts() + case KindJSDocParameterTag, KindJSDocPropertyTag: + return (*JSDocParameterOrPropertyTag)(unsafe.Pointer(n)).computeSubtreeFacts() + default: + return SubtreeFactsNone + } +} + +// ────────────────────────────────────────────────────────────────────── +// Node data accessor dispatch +// ────────────────────────────────────────────────────────────────────── + +var nodeNameOffsets = [KindCount]uint16{ + KindVariableDeclaration: uint16(unsafe.Offsetof(VariableDeclaration{}.name)) + 1, + KindParameter: uint16(unsafe.Offsetof(ParameterDeclaration{}.name)) + 1, + KindBindingElement: uint16(unsafe.Offsetof(BindingElement{}.name)) + 1, + KindFunctionDeclaration: uint16(unsafe.Offsetof(FunctionDeclaration{}.name)) + 1, + KindClassDeclaration: uint16(unsafe.Offsetof(ClassDeclaration{}.name)) + 1, + KindClassExpression: uint16(unsafe.Offsetof(ClassExpression{}.name)) + 1, + KindInterfaceDeclaration: uint16(unsafe.Offsetof(InterfaceDeclaration{}.name)) + 1, + KindTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.name)) + 1, + KindJSTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.name)) + 1, + KindEnumMember: uint16(unsafe.Offsetof(EnumMember{}.name)) + 1, + KindEnumDeclaration: uint16(unsafe.Offsetof(EnumDeclaration{}.name)) + 1, + KindNamespaceImport: uint16(unsafe.Offsetof(NamespaceImport{}.name)) + 1, + KindNamespaceExportDeclaration: uint16(unsafe.Offsetof(NamespaceExportDeclaration{}.name)) + 1, + KindNamespaceExport: uint16(unsafe.Offsetof(NamespaceExport{}.name)) + 1, + KindExportSpecifier: uint16(unsafe.Offsetof(ExportSpecifier{}.name)) + 1, + KindGetAccessor: uint16(unsafe.Offsetof(GetAccessorDeclaration{}.name)) + 1, + KindSetAccessor: uint16(unsafe.Offsetof(SetAccessorDeclaration{}.name)) + 1, + KindMethodSignature: uint16(unsafe.Offsetof(MethodSignatureDeclaration{}.name)) + 1, + KindMethodDeclaration: uint16(unsafe.Offsetof(MethodDeclaration{}.name)) + 1, + KindPropertySignature: uint16(unsafe.Offsetof(PropertySignatureDeclaration{}.name)) + 1, + KindPropertyDeclaration: uint16(unsafe.Offsetof(PropertyDeclaration{}.name)) + 1, + KindFunctionExpression: uint16(unsafe.Offsetof(FunctionExpression{}.name)) + 1, + KindPropertyAccessExpression: uint16(unsafe.Offsetof(PropertyAccessExpression{}.name)) + 1, + KindMetaProperty: uint16(unsafe.Offsetof(MetaProperty{}.name)) + 1, + KindPropertyAssignment: uint16(unsafe.Offsetof(PropertyAssignment{}.name)) + 1, + KindShorthandPropertyAssignment: uint16(unsafe.Offsetof(ShorthandPropertyAssignment{}.name)) + 1, + KindImportAttribute: uint16(unsafe.Offsetof(ImportAttribute{}.name)) + 1, + KindNamedTupleMember: uint16(unsafe.Offsetof(NamedTupleMember{}.name)) + 1, + KindJsxNamespacedName: uint16(unsafe.Offsetof(JsxNamespacedName{}.name)) + 1, + KindJsxAttribute: uint16(unsafe.Offsetof(JsxAttribute{}.name)) + 1, + KindJSDocCallbackTag: uint16(unsafe.Offsetof(JSDocCallbackTag{}.name)) + 1, + KindJSDocTypedefTag: uint16(unsafe.Offsetof(JSDocTypedefTag{}.name)) + 1, + KindJSDocNameReference: uint16(unsafe.Offsetof(JSDocNameReference{}.name)) + 1, + KindModuleDeclaration: uint16(unsafe.Offsetof(ModuleDeclaration{}.name)) + 1, + KindImportEqualsDeclaration: uint16(unsafe.Offsetof(ImportEqualsDeclaration{}.name)) + 1, + KindImportClause: uint16(unsafe.Offsetof(ImportClause{}.name)) + 1, + KindImportSpecifier: uint16(unsafe.Offsetof(ImportSpecifier{}.name)) + 1, + KindJSDocLink: uint16(unsafe.Offsetof(JSDocLink{}.name)) + 1, + KindJSDocLinkPlain: uint16(unsafe.Offsetof(JSDocLinkPlain{}.name)) + 1, + KindJSDocLinkCode: uint16(unsafe.Offsetof(JSDocLinkCode{}.name)) + 1, + KindTypeParameter: uint16(unsafe.Offsetof(TypeParameterDeclaration{}.name)) + 1, + KindJSDocParameterTag: uint16(unsafe.Offsetof(JSDocParameterOrPropertyTag{}.name)) + 1, + KindJSDocPropertyTag: uint16(unsafe.Offsetof(JSDocParameterOrPropertyTag{}.name)) + 1, +} + +func (n *Node) Name() *DeclarationName { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeNameOffsets)) { + return nil + } + offset := nodeNameOffsets[kind] + if offset == 0 { + return nil + } + return *(**DeclarationName)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeModifiersOffsets = [KindCount]uint16{ + KindVariableStatement: uint16(unsafe.Offsetof(VariableStatement{}.modifiers)) + 1, + KindParameter: uint16(unsafe.Offsetof(ParameterDeclaration{}.modifiers)) + 1, + KindMissingDeclaration: uint16(unsafe.Offsetof(MissingDeclaration{}.modifiers)) + 1, + KindFunctionDeclaration: uint16(unsafe.Offsetof(FunctionDeclaration{}.modifiers)) + 1, + KindClassDeclaration: uint16(unsafe.Offsetof(ClassDeclaration{}.modifiers)) + 1, + KindClassExpression: uint16(unsafe.Offsetof(ClassExpression{}.modifiers)) + 1, + KindInterfaceDeclaration: uint16(unsafe.Offsetof(InterfaceDeclaration{}.modifiers)) + 1, + KindTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.modifiers)) + 1, + KindJSTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.modifiers)) + 1, + KindEnumMember: uint16(unsafe.Offsetof(EnumMember{}.modifiers)) + 1, + KindEnumDeclaration: uint16(unsafe.Offsetof(EnumDeclaration{}.modifiers)) + 1, + KindImportDeclaration: uint16(unsafe.Offsetof(ImportDeclaration{}.modifiers)) + 1, + KindJSImportDeclaration: uint16(unsafe.Offsetof(ImportDeclaration{}.modifiers)) + 1, + KindExportAssignment: uint16(unsafe.Offsetof(ExportAssignment{}.modifiers)) + 1, + KindNamespaceExportDeclaration: uint16(unsafe.Offsetof(NamespaceExportDeclaration{}.modifiers)) + 1, + KindConstructor: uint16(unsafe.Offsetof(ConstructorDeclaration{}.modifiers)) + 1, + KindGetAccessor: uint16(unsafe.Offsetof(GetAccessorDeclaration{}.modifiers)) + 1, + KindSetAccessor: uint16(unsafe.Offsetof(SetAccessorDeclaration{}.modifiers)) + 1, + KindIndexSignature: uint16(unsafe.Offsetof(IndexSignatureDeclaration{}.modifiers)) + 1, + KindMethodSignature: uint16(unsafe.Offsetof(MethodSignatureDeclaration{}.modifiers)) + 1, + KindMethodDeclaration: uint16(unsafe.Offsetof(MethodDeclaration{}.modifiers)) + 1, + KindPropertySignature: uint16(unsafe.Offsetof(PropertySignatureDeclaration{}.modifiers)) + 1, + KindPropertyDeclaration: uint16(unsafe.Offsetof(PropertyDeclaration{}.modifiers)) + 1, + KindClassStaticBlockDeclaration: uint16(unsafe.Offsetof(ClassStaticBlockDeclaration{}.modifiers)) + 1, + KindBinaryExpression: uint16(unsafe.Offsetof(BinaryExpression{}.modifiers)) + 1, + KindArrowFunction: uint16(unsafe.Offsetof(ArrowFunction{}.modifiers)) + 1, + KindFunctionExpression: uint16(unsafe.Offsetof(FunctionExpression{}.modifiers)) + 1, + KindPropertyAssignment: uint16(unsafe.Offsetof(PropertyAssignment{}.modifiers)) + 1, + KindShorthandPropertyAssignment: uint16(unsafe.Offsetof(ShorthandPropertyAssignment{}.modifiers)) + 1, + KindFunctionType: uint16(unsafe.Offsetof(FunctionTypeNode{}.modifiers)) + 1, + KindConstructorType: uint16(unsafe.Offsetof(ConstructorTypeNode{}.modifiers)) + 1, + KindModuleDeclaration: uint16(unsafe.Offsetof(ModuleDeclaration{}.modifiers)) + 1, + KindImportEqualsDeclaration: uint16(unsafe.Offsetof(ImportEqualsDeclaration{}.modifiers)) + 1, + KindExportDeclaration: uint16(unsafe.Offsetof(ExportDeclaration{}.modifiers)) + 1, + KindTypeParameter: uint16(unsafe.Offsetof(TypeParameterDeclaration{}.modifiers)) + 1, +} + +func (n *Node) Modifiers() *ModifierList { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeModifiersOffsets)) { + return nil + } + offset := nodeModifiersOffsets[kind] + if offset == 0 { + return nil + } + return *(**ModifierList)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeFlowNodeDataOffsets = [KindCount]uint16{ + KindIdentifier: uint16(unsafe.Offsetof(Identifier{}.FlowNodeBase)) + 1, + KindFalseKeyword: uint16(unsafe.Offsetof(KeywordExpression{}.FlowNodeBase)) + 1, + KindImportKeyword: uint16(unsafe.Offsetof(KeywordExpression{}.FlowNodeBase)) + 1, + KindNullKeyword: uint16(unsafe.Offsetof(KeywordExpression{}.FlowNodeBase)) + 1, + KindSuperKeyword: uint16(unsafe.Offsetof(KeywordExpression{}.FlowNodeBase)) + 1, + KindThisKeyword: uint16(unsafe.Offsetof(KeywordExpression{}.FlowNodeBase)) + 1, + KindTrueKeyword: uint16(unsafe.Offsetof(KeywordExpression{}.FlowNodeBase)) + 1, + KindQualifiedName: uint16(unsafe.Offsetof(QualifiedName{}.FlowNodeBase)) + 1, + KindEmptyStatement: uint16(unsafe.Offsetof(EmptyStatement{}.FlowNodeBase)) + 1, + KindIfStatement: uint16(unsafe.Offsetof(IfStatement{}.FlowNodeBase)) + 1, + KindDoStatement: uint16(unsafe.Offsetof(DoStatement{}.FlowNodeBase)) + 1, + KindWhileStatement: uint16(unsafe.Offsetof(WhileStatement{}.FlowNodeBase)) + 1, + KindForStatement: uint16(unsafe.Offsetof(ForStatement{}.FlowNodeBase)) + 1, + KindForInStatement: uint16(unsafe.Offsetof(ForInOrOfStatement{}.FlowNodeBase)) + 1, + KindForOfStatement: uint16(unsafe.Offsetof(ForInOrOfStatement{}.FlowNodeBase)) + 1, + KindBreakStatement: uint16(unsafe.Offsetof(BreakStatement{}.FlowNodeBase)) + 1, + KindContinueStatement: uint16(unsafe.Offsetof(ContinueStatement{}.FlowNodeBase)) + 1, + KindReturnStatement: uint16(unsafe.Offsetof(ReturnStatement{}.FlowNodeBase)) + 1, + KindWithStatement: uint16(unsafe.Offsetof(WithStatement{}.FlowNodeBase)) + 1, + KindSwitchStatement: uint16(unsafe.Offsetof(SwitchStatement{}.FlowNodeBase)) + 1, + KindThrowStatement: uint16(unsafe.Offsetof(ThrowStatement{}.FlowNodeBase)) + 1, + KindTryStatement: uint16(unsafe.Offsetof(TryStatement{}.FlowNodeBase)) + 1, + KindDebuggerStatement: uint16(unsafe.Offsetof(DebuggerStatement{}.FlowNodeBase)) + 1, + KindLabeledStatement: uint16(unsafe.Offsetof(LabeledStatement{}.FlowNodeBase)) + 1, + KindExpressionStatement: uint16(unsafe.Offsetof(ExpressionStatement{}.FlowNodeBase)) + 1, + KindBlock: uint16(unsafe.Offsetof(Block{}.FlowNodeBase)) + 1, + KindVariableStatement: uint16(unsafe.Offsetof(VariableStatement{}.FlowNodeBase)) + 1, + KindBindingElement: uint16(unsafe.Offsetof(BindingElement{}.FlowNodeBase)) + 1, + KindMissingDeclaration: uint16(unsafe.Offsetof(MissingDeclaration{}.FlowNodeBase)) + 1, + KindFunctionDeclaration: uint16(unsafe.Offsetof(FunctionDeclaration{}.FlowNodeBase)) + 1, + KindClassDeclaration: uint16(unsafe.Offsetof(ClassDeclaration{}.FlowNodeBase)) + 1, + KindInterfaceDeclaration: uint16(unsafe.Offsetof(InterfaceDeclaration{}.FlowNodeBase)) + 1, + KindTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.FlowNodeBase)) + 1, + KindJSTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.FlowNodeBase)) + 1, + KindEnumDeclaration: uint16(unsafe.Offsetof(EnumDeclaration{}.FlowNodeBase)) + 1, + KindModuleBlock: uint16(unsafe.Offsetof(ModuleBlock{}.FlowNodeBase)) + 1, + KindNotEmittedStatement: uint16(unsafe.Offsetof(NotEmittedStatement{}.FlowNodeBase)) + 1, + KindImportDeclaration: uint16(unsafe.Offsetof(ImportDeclaration{}.FlowNodeBase)) + 1, + KindJSImportDeclaration: uint16(unsafe.Offsetof(ImportDeclaration{}.FlowNodeBase)) + 1, + KindExportAssignment: uint16(unsafe.Offsetof(ExportAssignment{}.FlowNodeBase)) + 1, + KindNamespaceExportDeclaration: uint16(unsafe.Offsetof(NamespaceExportDeclaration{}.FlowNodeBase)) + 1, + KindGetAccessor: uint16(unsafe.Offsetof(GetAccessorDeclaration{}.FlowNodeBase)) + 1, + KindSetAccessor: uint16(unsafe.Offsetof(SetAccessorDeclaration{}.FlowNodeBase)) + 1, + KindMethodDeclaration: uint16(unsafe.Offsetof(MethodDeclaration{}.FlowNodeBase)) + 1, + KindArrowFunction: uint16(unsafe.Offsetof(ArrowFunction{}.FlowNodeBase)) + 1, + KindFunctionExpression: uint16(unsafe.Offsetof(FunctionExpression{}.FlowNodeBase)) + 1, + KindPropertyAccessExpression: uint16(unsafe.Offsetof(PropertyAccessExpression{}.FlowNodeBase)) + 1, + KindElementAccessExpression: uint16(unsafe.Offsetof(ElementAccessExpression{}.FlowNodeBase)) + 1, + KindMetaProperty: uint16(unsafe.Offsetof(MetaProperty{}.FlowNodeBase)) + 1, + KindModuleDeclaration: uint16(unsafe.Offsetof(ModuleDeclaration{}.FlowNodeBase)) + 1, + KindImportEqualsDeclaration: uint16(unsafe.Offsetof(ImportEqualsDeclaration{}.FlowNodeBase)) + 1, + KindExportDeclaration: uint16(unsafe.Offsetof(ExportDeclaration{}.FlowNodeBase)) + 1, +} + +func (n *Node) FlowNodeData() *FlowNodeBase { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeFlowNodeDataOffsets)) { + return nil + } + offset := nodeFlowNodeDataOffsets[kind] + if offset == 0 { + return nil + } + return (*FlowNodeBase)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeDeclarationDataOffsets = [KindCount]uint16{ + KindNoSubstitutionTemplateLiteral: uint16(unsafe.Offsetof(NoSubstitutionTemplateLiteral{}.DeclarationBase)) + 1, + KindVariableDeclaration: uint16(unsafe.Offsetof(VariableDeclaration{}.DeclarationBase)) + 1, + KindParameter: uint16(unsafe.Offsetof(ParameterDeclaration{}.DeclarationBase)) + 1, + KindBindingElement: uint16(unsafe.Offsetof(BindingElement{}.DeclarationBase)) + 1, + KindMissingDeclaration: uint16(unsafe.Offsetof(MissingDeclaration{}.DeclarationBase)) + 1, + KindFunctionDeclaration: uint16(unsafe.Offsetof(FunctionDeclaration{}.DeclarationBase)) + 1, + KindClassDeclaration: uint16(unsafe.Offsetof(ClassDeclaration{}.DeclarationBase)) + 1, + KindClassExpression: uint16(unsafe.Offsetof(ClassExpression{}.DeclarationBase)) + 1, + KindInterfaceDeclaration: uint16(unsafe.Offsetof(InterfaceDeclaration{}.DeclarationBase)) + 1, + KindTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.DeclarationBase)) + 1, + KindJSTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.DeclarationBase)) + 1, + KindEnumMember: uint16(unsafe.Offsetof(EnumMember{}.DeclarationBase)) + 1, + KindEnumDeclaration: uint16(unsafe.Offsetof(EnumDeclaration{}.DeclarationBase)) + 1, + KindImportDeclaration: uint16(unsafe.Offsetof(ImportDeclaration{}.DeclarationBase)) + 1, + KindJSImportDeclaration: uint16(unsafe.Offsetof(ImportDeclaration{}.DeclarationBase)) + 1, + KindNamespaceImport: uint16(unsafe.Offsetof(NamespaceImport{}.DeclarationBase)) + 1, + KindExportAssignment: uint16(unsafe.Offsetof(ExportAssignment{}.DeclarationBase)) + 1, + KindNamespaceExportDeclaration: uint16(unsafe.Offsetof(NamespaceExportDeclaration{}.DeclarationBase)) + 1, + KindNamespaceExport: uint16(unsafe.Offsetof(NamespaceExport{}.DeclarationBase)) + 1, + KindExportSpecifier: uint16(unsafe.Offsetof(ExportSpecifier{}.DeclarationBase)) + 1, + KindCallSignature: uint16(unsafe.Offsetof(CallSignatureDeclaration{}.DeclarationBase)) + 1, + KindConstructSignature: uint16(unsafe.Offsetof(ConstructSignatureDeclaration{}.DeclarationBase)) + 1, + KindConstructor: uint16(unsafe.Offsetof(ConstructorDeclaration{}.DeclarationBase)) + 1, + KindGetAccessor: uint16(unsafe.Offsetof(GetAccessorDeclaration{}.DeclarationBase)) + 1, + KindSetAccessor: uint16(unsafe.Offsetof(SetAccessorDeclaration{}.DeclarationBase)) + 1, + KindIndexSignature: uint16(unsafe.Offsetof(IndexSignatureDeclaration{}.DeclarationBase)) + 1, + KindMethodSignature: uint16(unsafe.Offsetof(MethodSignatureDeclaration{}.DeclarationBase)) + 1, + KindMethodDeclaration: uint16(unsafe.Offsetof(MethodDeclaration{}.DeclarationBase)) + 1, + KindPropertySignature: uint16(unsafe.Offsetof(PropertySignatureDeclaration{}.DeclarationBase)) + 1, + KindPropertyDeclaration: uint16(unsafe.Offsetof(PropertyDeclaration{}.DeclarationBase)) + 1, + KindSemicolonClassElement: uint16(unsafe.Offsetof(SemicolonClassElement{}.DeclarationBase)) + 1, + KindClassStaticBlockDeclaration: uint16(unsafe.Offsetof(ClassStaticBlockDeclaration{}.DeclarationBase)) + 1, + KindBinaryExpression: uint16(unsafe.Offsetof(BinaryExpression{}.DeclarationBase)) + 1, + KindArrowFunction: uint16(unsafe.Offsetof(ArrowFunction{}.DeclarationBase)) + 1, + KindFunctionExpression: uint16(unsafe.Offsetof(FunctionExpression{}.DeclarationBase)) + 1, + KindCallExpression: uint16(unsafe.Offsetof(CallExpression{}.DeclarationBase)) + 1, + KindObjectLiteralExpression: uint16(unsafe.Offsetof(ObjectLiteralExpression{}.DeclarationBase)) + 1, + KindSpreadAssignment: uint16(unsafe.Offsetof(SpreadAssignment{}.DeclarationBase)) + 1, + KindPropertyAssignment: uint16(unsafe.Offsetof(PropertyAssignment{}.DeclarationBase)) + 1, + KindShorthandPropertyAssignment: uint16(unsafe.Offsetof(ShorthandPropertyAssignment{}.DeclarationBase)) + 1, + KindMappedType: uint16(unsafe.Offsetof(MappedTypeNode{}.DeclarationBase)) + 1, + KindTypeLiteral: uint16(unsafe.Offsetof(TypeLiteralNode{}.DeclarationBase)) + 1, + KindNamedTupleMember: uint16(unsafe.Offsetof(NamedTupleMember{}.DeclarationBase)) + 1, + KindFunctionType: uint16(unsafe.Offsetof(FunctionTypeNode{}.DeclarationBase)) + 1, + KindConstructorType: uint16(unsafe.Offsetof(ConstructorTypeNode{}.DeclarationBase)) + 1, + KindJsxAttributes: uint16(unsafe.Offsetof(JsxAttributes{}.DeclarationBase)) + 1, + KindJsxAttribute: uint16(unsafe.Offsetof(JsxAttribute{}.DeclarationBase)) + 1, + KindJSDocSignature: uint16(unsafe.Offsetof(JSDocSignature{}.DeclarationBase)) + 1, + KindSourceFile: uint16(unsafe.Offsetof(SourceFile{}.DeclarationBase)) + 1, + KindModuleDeclaration: uint16(unsafe.Offsetof(ModuleDeclaration{}.DeclarationBase)) + 1, + KindImportEqualsDeclaration: uint16(unsafe.Offsetof(ImportEqualsDeclaration{}.DeclarationBase)) + 1, + KindExportDeclaration: uint16(unsafe.Offsetof(ExportDeclaration{}.DeclarationBase)) + 1, + KindImportClause: uint16(unsafe.Offsetof(ImportClause{}.DeclarationBase)) + 1, + KindImportSpecifier: uint16(unsafe.Offsetof(ImportSpecifier{}.DeclarationBase)) + 1, + KindTypeParameter: uint16(unsafe.Offsetof(TypeParameterDeclaration{}.DeclarationBase)) + 1, + KindJSDocTypeLiteral: uint16(unsafe.Offsetof(JSDocTypeLiteral{}.DeclarationBase)) + 1, +} + +func (n *Node) DeclarationData() *DeclarationBase { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeDeclarationDataOffsets)) { + return nil + } + offset := nodeDeclarationDataOffsets[kind] + if offset == 0 { + return nil + } + return (*DeclarationBase)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeLocalsContainerDataOffsets = [KindCount]uint16{ + KindForStatement: uint16(unsafe.Offsetof(ForStatement{}.LocalsContainerBase)) + 1, + KindForInStatement: uint16(unsafe.Offsetof(ForInOrOfStatement{}.LocalsContainerBase)) + 1, + KindForOfStatement: uint16(unsafe.Offsetof(ForInOrOfStatement{}.LocalsContainerBase)) + 1, + KindCaseBlock: uint16(unsafe.Offsetof(CaseBlock{}.LocalsContainerBase)) + 1, + KindCatchClause: uint16(unsafe.Offsetof(CatchClause{}.LocalsContainerBase)) + 1, + KindBlock: uint16(unsafe.Offsetof(Block{}.LocalsContainerBase)) + 1, + KindFunctionDeclaration: uint16(unsafe.Offsetof(FunctionDeclaration{}.LocalsContainerBase)) + 1, + KindClassDeclaration: uint16(unsafe.Offsetof(ClassDeclaration{}.LocalsContainerBase)) + 1, + KindClassExpression: uint16(unsafe.Offsetof(ClassExpression{}.LocalsContainerBase)) + 1, + KindTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.LocalsContainerBase)) + 1, + KindJSTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.LocalsContainerBase)) + 1, + KindCallSignature: uint16(unsafe.Offsetof(CallSignatureDeclaration{}.LocalsContainerBase)) + 1, + KindConstructSignature: uint16(unsafe.Offsetof(ConstructSignatureDeclaration{}.LocalsContainerBase)) + 1, + KindConstructor: uint16(unsafe.Offsetof(ConstructorDeclaration{}.LocalsContainerBase)) + 1, + KindGetAccessor: uint16(unsafe.Offsetof(GetAccessorDeclaration{}.LocalsContainerBase)) + 1, + KindSetAccessor: uint16(unsafe.Offsetof(SetAccessorDeclaration{}.LocalsContainerBase)) + 1, + KindIndexSignature: uint16(unsafe.Offsetof(IndexSignatureDeclaration{}.LocalsContainerBase)) + 1, + KindMethodSignature: uint16(unsafe.Offsetof(MethodSignatureDeclaration{}.LocalsContainerBase)) + 1, + KindMethodDeclaration: uint16(unsafe.Offsetof(MethodDeclaration{}.LocalsContainerBase)) + 1, + KindClassStaticBlockDeclaration: uint16(unsafe.Offsetof(ClassStaticBlockDeclaration{}.LocalsContainerBase)) + 1, + KindArrowFunction: uint16(unsafe.Offsetof(ArrowFunction{}.LocalsContainerBase)) + 1, + KindFunctionExpression: uint16(unsafe.Offsetof(FunctionExpression{}.LocalsContainerBase)) + 1, + KindConditionalType: uint16(unsafe.Offsetof(ConditionalTypeNode{}.LocalsContainerBase)) + 1, + KindMappedType: uint16(unsafe.Offsetof(MappedTypeNode{}.LocalsContainerBase)) + 1, + KindFunctionType: uint16(unsafe.Offsetof(FunctionTypeNode{}.LocalsContainerBase)) + 1, + KindConstructorType: uint16(unsafe.Offsetof(ConstructorTypeNode{}.LocalsContainerBase)) + 1, + KindJSDocSignature: uint16(unsafe.Offsetof(JSDocSignature{}.LocalsContainerBase)) + 1, + KindSourceFile: uint16(unsafe.Offsetof(SourceFile{}.LocalsContainerBase)) + 1, + KindModuleDeclaration: uint16(unsafe.Offsetof(ModuleDeclaration{}.LocalsContainerBase)) + 1, +} + +func (n *Node) LocalsContainerData() *LocalsContainerBase { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeLocalsContainerDataOffsets)) { + return nil + } + offset := nodeLocalsContainerDataOffsets[kind] + if offset == 0 { + return nil + } + return (*LocalsContainerBase)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeFunctionLikeDataOffsets = [KindCount]uint16{ + KindFunctionDeclaration: uint16(unsafe.Offsetof(FunctionDeclaration{}.FunctionLikeBase)) + 1, + KindCallSignature: uint16(unsafe.Offsetof(CallSignatureDeclaration{}.FunctionLikeBase)) + 1, + KindConstructSignature: uint16(unsafe.Offsetof(ConstructSignatureDeclaration{}.FunctionLikeBase)) + 1, + KindConstructor: uint16(unsafe.Offsetof(ConstructorDeclaration{}.FunctionLikeBase)) + 1, + KindGetAccessor: uint16(unsafe.Offsetof(GetAccessorDeclaration{}.FunctionLikeBase)) + 1, + KindSetAccessor: uint16(unsafe.Offsetof(SetAccessorDeclaration{}.FunctionLikeBase)) + 1, + KindIndexSignature: uint16(unsafe.Offsetof(IndexSignatureDeclaration{}.FunctionLikeBase)) + 1, + KindMethodSignature: uint16(unsafe.Offsetof(MethodSignatureDeclaration{}.FunctionLikeBase)) + 1, + KindMethodDeclaration: uint16(unsafe.Offsetof(MethodDeclaration{}.FunctionLikeBase)) + 1, + KindArrowFunction: uint16(unsafe.Offsetof(ArrowFunction{}.FunctionLikeBase)) + 1, + KindFunctionExpression: uint16(unsafe.Offsetof(FunctionExpression{}.FunctionLikeBase)) + 1, + KindFunctionType: uint16(unsafe.Offsetof(FunctionTypeNode{}.FunctionLikeBase)) + 1, + KindConstructorType: uint16(unsafe.Offsetof(ConstructorTypeNode{}.FunctionLikeBase)) + 1, + KindJSDocSignature: uint16(unsafe.Offsetof(JSDocSignature{}.FunctionLikeBase)) + 1, +} + +func (n *Node) FunctionLikeData() *FunctionLikeBase { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeFunctionLikeDataOffsets)) { + return nil + } + offset := nodeFunctionLikeDataOffsets[kind] + if offset == 0 { + return nil + } + return (*FunctionLikeBase)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeExpressionOffsets = [kindFlowReduceLabelData + 1]uint16{ + KindComputedPropertyName: uint16(unsafe.Offsetof(ComputedPropertyName{}.Expression)) + 1, + KindDecorator: uint16(unsafe.Offsetof(Decorator{}.Expression)) + 1, + KindIfStatement: uint16(unsafe.Offsetof(IfStatement{}.Expression)) + 1, + KindDoStatement: uint16(unsafe.Offsetof(DoStatement{}.Expression)) + 1, + KindWhileStatement: uint16(unsafe.Offsetof(WhileStatement{}.Expression)) + 1, + KindForInStatement: uint16(unsafe.Offsetof(ForInOrOfStatement{}.Expression)) + 1, + KindForOfStatement: uint16(unsafe.Offsetof(ForInOrOfStatement{}.Expression)) + 1, + KindReturnStatement: uint16(unsafe.Offsetof(ReturnStatement{}.Expression)) + 1, + KindWithStatement: uint16(unsafe.Offsetof(WithStatement{}.Expression)) + 1, + KindSwitchStatement: uint16(unsafe.Offsetof(SwitchStatement{}.Expression)) + 1, + KindCaseClause: uint16(unsafe.Offsetof(CaseOrDefaultClause{}.Expression)) + 1, + KindThrowStatement: uint16(unsafe.Offsetof(ThrowStatement{}.Expression)) + 1, + KindExpressionStatement: uint16(unsafe.Offsetof(ExpressionStatement{}.Expression)) + 1, + KindExternalModuleReference: uint16(unsafe.Offsetof(ExternalModuleReference{}.Expression)) + 1, + KindExportAssignment: uint16(unsafe.Offsetof(ExportAssignment{}.Expression)) + 1, + KindYieldExpression: uint16(unsafe.Offsetof(YieldExpression{}.Expression)) + 1, + KindAsExpression: uint16(unsafe.Offsetof(AsExpression{}.Expression)) + 1, + KindSatisfiesExpression: uint16(unsafe.Offsetof(SatisfiesExpression{}.Expression)) + 1, + KindPropertyAccessExpression: uint16(unsafe.Offsetof(PropertyAccessExpression{}.Expression)) + 1, + KindElementAccessExpression: uint16(unsafe.Offsetof(ElementAccessExpression{}.Expression)) + 1, + KindCallExpression: uint16(unsafe.Offsetof(CallExpression{}.Expression)) + 1, + KindNewExpression: uint16(unsafe.Offsetof(NewExpression{}.Expression)) + 1, + KindNonNullExpression: uint16(unsafe.Offsetof(NonNullExpression{}.Expression)) + 1, + KindSpreadElement: uint16(unsafe.Offsetof(SpreadElement{}.Expression)) + 1, + KindTemplateSpan: uint16(unsafe.Offsetof(TemplateSpan{}.Expression)) + 1, + KindParenthesizedExpression: uint16(unsafe.Offsetof(ParenthesizedExpression{}.Expression)) + 1, + KindSpreadAssignment: uint16(unsafe.Offsetof(SpreadAssignment{}.Expression)) + 1, + KindDeleteExpression: uint16(unsafe.Offsetof(DeleteExpression{}.Expression)) + 1, + KindTypeOfExpression: uint16(unsafe.Offsetof(TypeOfExpression{}.Expression)) + 1, + KindVoidExpression: uint16(unsafe.Offsetof(VoidExpression{}.Expression)) + 1, + KindAwaitExpression: uint16(unsafe.Offsetof(AwaitExpression{}.Expression)) + 1, + KindTypeAssertionExpression: uint16(unsafe.Offsetof(TypeAssertion{}.Expression)) + 1, + KindExpressionWithTypeArguments: uint16(unsafe.Offsetof(ExpressionWithTypeArguments{}.Expression)) + 1, + KindPartiallyEmittedExpression: uint16(unsafe.Offsetof(PartiallyEmittedExpression{}.Expression)) + 1, + KindJsxSpreadAttribute: uint16(unsafe.Offsetof(JsxSpreadAttribute{}.Expression)) + 1, + KindJsxExpression: uint16(unsafe.Offsetof(JsxExpression{}.Expression)) + 1, +} + +func (n *Node) Expression() *Node { + offset := nodeExpressionOffsets[n.Kind] + if offset == 0 { + return n.expressionUnsupported() + } + return *(**Node)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeTypeOffsets = [KindCount]uint16{ + KindVariableDeclaration: uint16(unsafe.Offsetof(VariableDeclaration{}.Type)) + 1, + KindParameter: uint16(unsafe.Offsetof(ParameterDeclaration{}.Type)) + 1, + KindFunctionDeclaration: uint16(unsafe.Offsetof(FunctionDeclaration{}.Type)) + 1, + KindTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.Type)) + 1, + KindJSTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.Type)) + 1, + KindExportAssignment: uint16(unsafe.Offsetof(ExportAssignment{}.Type)) + 1, + KindCallSignature: uint16(unsafe.Offsetof(CallSignatureDeclaration{}.Type)) + 1, + KindConstructSignature: uint16(unsafe.Offsetof(ConstructSignatureDeclaration{}.Type)) + 1, + KindConstructor: uint16(unsafe.Offsetof(ConstructorDeclaration{}.Type)) + 1, + KindGetAccessor: uint16(unsafe.Offsetof(GetAccessorDeclaration{}.Type)) + 1, + KindSetAccessor: uint16(unsafe.Offsetof(SetAccessorDeclaration{}.Type)) + 1, + KindIndexSignature: uint16(unsafe.Offsetof(IndexSignatureDeclaration{}.Type)) + 1, + KindMethodSignature: uint16(unsafe.Offsetof(MethodSignatureDeclaration{}.Type)) + 1, + KindMethodDeclaration: uint16(unsafe.Offsetof(MethodDeclaration{}.Type)) + 1, + KindPropertySignature: uint16(unsafe.Offsetof(PropertySignatureDeclaration{}.Type)) + 1, + KindPropertyDeclaration: uint16(unsafe.Offsetof(PropertyDeclaration{}.Type)) + 1, + KindBinaryExpression: uint16(unsafe.Offsetof(BinaryExpression{}.Type)) + 1, + KindArrowFunction: uint16(unsafe.Offsetof(ArrowFunction{}.Type)) + 1, + KindFunctionExpression: uint16(unsafe.Offsetof(FunctionExpression{}.Type)) + 1, + KindAsExpression: uint16(unsafe.Offsetof(AsExpression{}.Type)) + 1, + KindSatisfiesExpression: uint16(unsafe.Offsetof(SatisfiesExpression{}.Type)) + 1, + KindPropertyAssignment: uint16(unsafe.Offsetof(PropertyAssignment{}.Type)) + 1, + KindShorthandPropertyAssignment: uint16(unsafe.Offsetof(ShorthandPropertyAssignment{}.Type)) + 1, + KindTypeAssertionExpression: uint16(unsafe.Offsetof(TypeAssertion{}.Type)) + 1, + KindTypeOperator: uint16(unsafe.Offsetof(TypeOperatorNode{}.Type)) + 1, + KindTypePredicate: uint16(unsafe.Offsetof(TypePredicateNode{}.Type)) + 1, + KindMappedType: uint16(unsafe.Offsetof(MappedTypeNode{}.Type)) + 1, + KindNamedTupleMember: uint16(unsafe.Offsetof(NamedTupleMember{}.Type)) + 1, + KindOptionalType: uint16(unsafe.Offsetof(OptionalTypeNode{}.Type)) + 1, + KindRestType: uint16(unsafe.Offsetof(RestTypeNode{}.Type)) + 1, + KindParenthesizedType: uint16(unsafe.Offsetof(ParenthesizedTypeNode{}.Type)) + 1, + KindFunctionType: uint16(unsafe.Offsetof(FunctionTypeNode{}.Type)) + 1, + KindConstructorType: uint16(unsafe.Offsetof(ConstructorTypeNode{}.Type)) + 1, + KindTemplateLiteralTypeSpan: uint16(unsafe.Offsetof(TemplateLiteralTypeSpan{}.Type)) + 1, + KindJSDocTypeExpression: uint16(unsafe.Offsetof(JSDocTypeExpression{}.Type)) + 1, + KindJSDocNonNullableType: uint16(unsafe.Offsetof(JSDocNonNullableType{}.Type)) + 1, + KindJSDocNullableType: uint16(unsafe.Offsetof(JSDocNullableType{}.Type)) + 1, + KindJSDocOptionalType: uint16(unsafe.Offsetof(JSDocOptionalType{}.Type)) + 1, + KindJSDocSignature: uint16(unsafe.Offsetof(JSDocSignature{}.Type)) + 1, + KindJSDocParameterTag: uint16(unsafe.Offsetof(JSDocParameterOrPropertyTag{}.TypeExpression)) + 1, + KindJSDocPropertyTag: uint16(unsafe.Offsetof(JSDocParameterOrPropertyTag{}.TypeExpression)) + 1, +} + +func (n *Node) Type() *Node { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeTypeOffsets)) { + return nil + } + offset := nodeTypeOffsets[kind] + if offset == 0 { + return nil + } + return *(**Node)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeInitializerOffsets = [KindCount]uint16{ + KindForStatement: uint16(unsafe.Offsetof(ForStatement{}.Initializer)) + 1, + KindForInStatement: uint16(unsafe.Offsetof(ForInOrOfStatement{}.Initializer)) + 1, + KindForOfStatement: uint16(unsafe.Offsetof(ForInOrOfStatement{}.Initializer)) + 1, + KindVariableDeclaration: uint16(unsafe.Offsetof(VariableDeclaration{}.Initializer)) + 1, + KindParameter: uint16(unsafe.Offsetof(ParameterDeclaration{}.Initializer)) + 1, + KindBindingElement: uint16(unsafe.Offsetof(BindingElement{}.Initializer)) + 1, + KindEnumMember: uint16(unsafe.Offsetof(EnumMember{}.Initializer)) + 1, + KindPropertySignature: uint16(unsafe.Offsetof(PropertySignatureDeclaration{}.Initializer)) + 1, + KindPropertyDeclaration: uint16(unsafe.Offsetof(PropertyDeclaration{}.Initializer)) + 1, + KindPropertyAssignment: uint16(unsafe.Offsetof(PropertyAssignment{}.Initializer)) + 1, + KindJsxAttribute: uint16(unsafe.Offsetof(JsxAttribute{}.Initializer)) + 1, +} + +func (n *Node) Initializer() *Node { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeInitializerOffsets)) { + panic("Unhandled case in Node.Initializer") + } + offset := nodeInitializerOffsets[kind] + if offset == 0 { + panic("Unhandled case in Node.Initializer") + } + return *(**Node)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeTextOffsets = [kindFlowReduceLabelData + 1]uint16{ + KindNumericLiteral: uint16(unsafe.Offsetof(NumericLiteral{}.Text)) + 1, + KindBigIntLiteral: uint16(unsafe.Offsetof(BigIntLiteral{}.Text)) + 1, + KindStringLiteral: uint16(unsafe.Offsetof(StringLiteral{}.Text)) + 1, + KindRegularExpressionLiteral: uint16(unsafe.Offsetof(RegularExpressionLiteral{}.Text)) + 1, + KindNoSubstitutionTemplateLiteral: uint16(unsafe.Offsetof(NoSubstitutionTemplateLiteral{}.Text)) + 1, + KindTemplateHead: uint16(unsafe.Offsetof(TemplateHead{}.Text)) + 1, + KindTemplateMiddle: uint16(unsafe.Offsetof(TemplateMiddle{}.Text)) + 1, + KindTemplateTail: uint16(unsafe.Offsetof(TemplateTail{}.Text)) + 1, + KindIdentifier: uint16(unsafe.Offsetof(Identifier{}.Text)) + 1, + KindPrivateIdentifier: uint16(unsafe.Offsetof(PrivateIdentifier{}.Text)) + 1, +} + +var nodePropagateSubtreeFactsExclusions = [KindCount]SubtreeFacts{ + KindCatchClause: SubtreeExclusionsCatchClause, + KindVariableDeclarationList: SubtreeExclusionsVariableDeclarationList, + KindObjectBindingPattern: SubtreeExclusionsBindingPattern, + KindArrayBindingPattern: SubtreeExclusionsBindingPattern, + KindParameter: SubtreeExclusionsParameter, + KindFunctionDeclaration: SubtreeExclusionsFunction, + KindClassDeclaration: SubtreeExclusionsClass, + KindClassExpression: SubtreeExclusionsClass, + KindModuleDeclaration: SubtreeExclusionsModule, + KindConstructor: SubtreeExclusionsConstructor, + KindArrowFunction: SubtreeExclusionsArrowFunction, + KindFunctionExpression: SubtreeExclusionsFunction, + KindAsExpression: SubtreeExclusionsOuterExpression, + KindSatisfiesExpression: SubtreeExclusionsOuterExpression, + KindPropertyAccessExpression: SubtreeExclusionsPropertyAccess, + KindElementAccessExpression: SubtreeExclusionsElementAccess, + KindCallExpression: SubtreeExclusionsCall, + KindNewExpression: SubtreeExclusionsNew, + KindArrayLiteralExpression: SubtreeExclusionsArrayLiteral, + KindObjectLiteralExpression: SubtreeExclusionsObjectLiteral, + KindTypeAssertionExpression: SubtreeExclusionsOuterExpression, +} + +func (n *Node) propagateSubtreeFacts() SubtreeFacts { + facts := n.SubtreeFacts() + switch n.Kind { + case KindGetAccessor, KindSetAccessor: + return facts & ^SubtreeExclusionsAccessor | propagateSubtreeFacts(n.Name()) + case KindMethodDeclaration: + return facts & ^SubtreeExclusionsMethod | propagateSubtreeFacts(n.Name()) + case KindPropertyDeclaration: + return facts & ^SubtreeExclusionsProperty | propagateSubtreeFacts(n.Name()) + } + kind := uint16(n.Kind) + if kind >= uint16(len(nodePropagateSubtreeFactsExclusions)) { + return facts + } + return facts & ^nodePropagateSubtreeFactsExclusions[kind] +} + +var nodeExportableDataOffsets = [KindCount]uint16{ + KindVariableDeclaration: uint16(unsafe.Offsetof(VariableDeclaration{}.ExportableBase)) + 1, + KindBindingElement: uint16(unsafe.Offsetof(BindingElement{}.ExportableBase)) + 1, + KindFunctionDeclaration: uint16(unsafe.Offsetof(FunctionDeclaration{}.ExportableBase)) + 1, + KindClassDeclaration: uint16(unsafe.Offsetof(ClassDeclaration{}.ExportableBase)) + 1, + KindClassExpression: uint16(unsafe.Offsetof(ClassExpression{}.ExportableBase)) + 1, + KindInterfaceDeclaration: uint16(unsafe.Offsetof(InterfaceDeclaration{}.ExportableBase)) + 1, + KindTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.ExportableBase)) + 1, + KindJSTypeAliasDeclaration: uint16(unsafe.Offsetof(TypeAliasDeclaration{}.ExportableBase)) + 1, + KindEnumDeclaration: uint16(unsafe.Offsetof(EnumDeclaration{}.ExportableBase)) + 1, + KindNamespaceImport: uint16(unsafe.Offsetof(NamespaceImport{}.ExportableBase)) + 1, + KindExportSpecifier: uint16(unsafe.Offsetof(ExportSpecifier{}.ExportableBase)) + 1, + KindModuleDeclaration: uint16(unsafe.Offsetof(ModuleDeclaration{}.ExportableBase)) + 1, + KindImportEqualsDeclaration: uint16(unsafe.Offsetof(ImportEqualsDeclaration{}.ExportableBase)) + 1, + KindImportClause: uint16(unsafe.Offsetof(ImportClause{}.ExportableBase)) + 1, + KindImportSpecifier: uint16(unsafe.Offsetof(ImportSpecifier{}.ExportableBase)) + 1, +} + +func (n *Node) ExportableData() *ExportableBase { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeExportableDataOffsets)) { + return nil + } + offset := nodeExportableDataOffsets[kind] + if offset == 0 { + return nil + } + return (*ExportableBase)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeClassLikeDataOffsets = [KindCount]uint16{ + KindClassDeclaration: uint16(unsafe.Offsetof(ClassDeclaration{}.ClassLikeBase)) + 1, + KindClassExpression: uint16(unsafe.Offsetof(ClassExpression{}.ClassLikeBase)) + 1, +} + +func (n *Node) ClassLikeData() *ClassLikeBase { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeClassLikeDataOffsets)) { + return nil + } + offset := nodeClassLikeDataOffsets[kind] + if offset == 0 { + return nil + } + return (*ClassLikeBase)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeBodyDataOffsets = [KindCount]uint16{ + KindFunctionDeclaration: uint16(unsafe.Offsetof(FunctionDeclaration{}.BodyBase)) + 1, + KindConstructor: uint16(unsafe.Offsetof(ConstructorDeclaration{}.BodyBase)) + 1, + KindGetAccessor: uint16(unsafe.Offsetof(GetAccessorDeclaration{}.BodyBase)) + 1, + KindSetAccessor: uint16(unsafe.Offsetof(SetAccessorDeclaration{}.BodyBase)) + 1, + KindMethodDeclaration: uint16(unsafe.Offsetof(MethodDeclaration{}.BodyBase)) + 1, + KindArrowFunction: uint16(unsafe.Offsetof(ArrowFunction{}.BodyBase)) + 1, + KindFunctionExpression: uint16(unsafe.Offsetof(FunctionExpression{}.BodyBase)) + 1, + KindModuleDeclaration: uint16(unsafe.Offsetof(ModuleDeclaration{}.BodyBase)) + 1, +} + +func (n *Node) BodyData() *BodyBase { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeBodyDataOffsets)) { + return nil + } + offset := nodeBodyDataOffsets[kind] + if offset == 0 { + return nil + } + return (*BodyBase)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeLiteralLikeDataOffsets = [KindCount]uint16{ + KindNumericLiteral: uint16(unsafe.Offsetof(NumericLiteral{}.LiteralLikeNodeBase)) + 1, + KindBigIntLiteral: uint16(unsafe.Offsetof(BigIntLiteral{}.LiteralLikeNodeBase)) + 1, + KindStringLiteral: uint16(unsafe.Offsetof(StringLiteral{}.LiteralLikeNodeBase)) + 1, + KindJsxText: uint16(unsafe.Offsetof(JsxText{}.LiteralLikeNodeBase)) + 1, + KindRegularExpressionLiteral: uint16(unsafe.Offsetof(RegularExpressionLiteral{}.LiteralLikeNodeBase)) + 1, + KindNoSubstitutionTemplateLiteral: uint16(unsafe.Offsetof(NoSubstitutionTemplateLiteral{}.LiteralLikeNodeBase)) + 1, + KindTemplateHead: uint16(unsafe.Offsetof(TemplateHead{}.LiteralLikeNodeBase)) + 1, + KindTemplateMiddle: uint16(unsafe.Offsetof(TemplateMiddle{}.LiteralLikeNodeBase)) + 1, + KindTemplateTail: uint16(unsafe.Offsetof(TemplateTail{}.LiteralLikeNodeBase)) + 1, +} + +func (n *Node) LiteralLikeData() *LiteralLikeNodeBase { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeLiteralLikeDataOffsets)) { + return nil + } + offset := nodeLiteralLikeDataOffsets[kind] + if offset == 0 { + return nil + } + return (*LiteralLikeNodeBase)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +var nodeTemplateLiteralLikeDataOffsets = [KindCount]uint16{ + KindNoSubstitutionTemplateLiteral: uint16(unsafe.Offsetof(NoSubstitutionTemplateLiteral{}.TemplateLiteralLikeNodeBase)) + 1, + KindTemplateHead: uint16(unsafe.Offsetof(TemplateHead{}.TemplateLiteralLikeNodeBase)) + 1, + KindTemplateMiddle: uint16(unsafe.Offsetof(TemplateMiddle{}.TemplateLiteralLikeNodeBase)) + 1, + KindTemplateTail: uint16(unsafe.Offsetof(TemplateTail{}.TemplateLiteralLikeNodeBase)) + 1, +} + +func (n *Node) TemplateLiteralLikeData() *TemplateLiteralLikeNodeBase { + kind := uint16(n.Kind) + if kind >= uint16(len(nodeTemplateLiteralLikeDataOffsets)) { + return nil + } + offset := nodeTemplateLiteralLikeDataOffsets[kind] + if offset == 0 { + return nil + } + return (*TemplateLiteralLikeNodeBase)(unsafe.Add(unsafe.Pointer(n), uintptr(offset-1))) +} + +func (n *Node) Clone(f NodeFactoryCoercible) *Node { + switch n.Kind { + case kindFlowSwitchClauseData, kindFlowReduceLabelData: + return nil + case KindUnknown, KindEndOfFile, KindSingleLineCommentTrivia, KindMultiLineCommentTrivia, KindNewLineTrivia, KindWhitespaceTrivia, KindConflictMarkerTrivia, KindNonTextFileMarkerTrivia, KindJsxTextAllWhiteSpaces, KindOpenBraceToken, KindCloseBraceToken, KindOpenParenToken, KindCloseParenToken, KindOpenBracketToken, KindCloseBracketToken, KindDotToken, KindDotDotDotToken, KindSemicolonToken, KindCommaToken, KindQuestionDotToken, KindLessThanToken, KindLessThanSlashToken, KindGreaterThanToken, KindLessThanEqualsToken, KindGreaterThanEqualsToken, KindEqualsEqualsToken, KindExclamationEqualsToken, KindEqualsEqualsEqualsToken, KindExclamationEqualsEqualsToken, KindEqualsGreaterThanToken, KindPlusToken, KindMinusToken, KindAsteriskToken, KindAsteriskAsteriskToken, KindSlashToken, KindPercentToken, KindPlusPlusToken, KindMinusMinusToken, KindLessThanLessThanToken, KindGreaterThanGreaterThanToken, KindGreaterThanGreaterThanGreaterThanToken, KindAmpersandToken, KindBarToken, KindCaretToken, KindExclamationToken, KindTildeToken, KindAmpersandAmpersandToken, KindBarBarToken, KindQuestionToken, KindColonToken, KindAtToken, KindQuestionQuestionToken, KindBacktickToken, KindHashToken, KindEqualsToken, KindPlusEqualsToken, KindMinusEqualsToken, KindAsteriskEqualsToken, KindAsteriskAsteriskEqualsToken, KindSlashEqualsToken, KindPercentEqualsToken, KindLessThanLessThanEqualsToken, KindGreaterThanGreaterThanEqualsToken, KindGreaterThanGreaterThanGreaterThanEqualsToken, KindAmpersandEqualsToken, KindBarEqualsToken, KindBarBarEqualsToken, KindAmpersandAmpersandEqualsToken, KindQuestionQuestionEqualsToken, KindCaretEqualsToken, KindJSDocCommentTextToken, KindBreakKeyword, KindCaseKeyword, KindCatchKeyword, KindClassKeyword, KindConstKeyword, KindContinueKeyword, KindDebuggerKeyword, KindDefaultKeyword, KindDeleteKeyword, KindDoKeyword, KindElseKeyword, KindEnumKeyword, KindExportKeyword, KindExtendsKeyword, KindFinallyKeyword, KindForKeyword, KindFunctionKeyword, KindIfKeyword, KindInKeyword, KindInstanceOfKeyword, KindNewKeyword, KindReturnKeyword, KindSwitchKeyword, KindThrowKeyword, KindTryKeyword, KindTypeOfKeyword, KindVarKeyword, KindWhileKeyword, KindWithKeyword, KindImplementsKeyword, KindInterfaceKeyword, KindLetKeyword, KindPackageKeyword, KindPrivateKeyword, KindProtectedKeyword, KindPublicKeyword, KindStaticKeyword, KindYieldKeyword, KindAbstractKeyword, KindAccessorKeyword, KindAsKeyword, KindAssertsKeyword, KindAssertKeyword, KindAsyncKeyword, KindAwaitKeyword, KindConstructorKeyword, KindDeclareKeyword, KindGetKeyword, KindImmediateKeyword, KindInferKeyword, KindIsKeyword, KindKeyOfKeyword, KindModuleKeyword, KindNamespaceKeyword, KindOutKeyword, KindReadonlyKeyword, KindRequireKeyword, KindSatisfiesKeyword, KindSetKeyword, KindTypeKeyword, KindUniqueKeyword, KindUsingKeyword, KindFromKeyword, KindGlobalKeyword, KindOverrideKeyword, KindOfKeyword, KindDeferKeyword: + return (*Token)(unsafe.Pointer(n)).Clone(f) + case KindNumericLiteral: + return (*NumericLiteral)(unsafe.Pointer(n)).Clone(f) + case KindBigIntLiteral: + return (*BigIntLiteral)(unsafe.Pointer(n)).Clone(f) + case KindStringLiteral: + return (*StringLiteral)(unsafe.Pointer(n)).Clone(f) + case KindJsxText: + return (*JsxText)(unsafe.Pointer(n)).Clone(f) + case KindRegularExpressionLiteral: + return (*RegularExpressionLiteral)(unsafe.Pointer(n)).Clone(f) + case KindNoSubstitutionTemplateLiteral: + return (*NoSubstitutionTemplateLiteral)(unsafe.Pointer(n)).Clone(f) + case KindTemplateHead: + return (*TemplateHead)(unsafe.Pointer(n)).Clone(f) + case KindTemplateMiddle: + return (*TemplateMiddle)(unsafe.Pointer(n)).Clone(f) + case KindTemplateTail: + return (*TemplateTail)(unsafe.Pointer(n)).Clone(f) + case KindIdentifier: + return (*Identifier)(unsafe.Pointer(n)).Clone(f) + case KindPrivateIdentifier: + return (*PrivateIdentifier)(unsafe.Pointer(n)).Clone(f) + case KindFalseKeyword, KindImportKeyword, KindNullKeyword, KindSuperKeyword, KindThisKeyword, KindTrueKeyword: + return (*KeywordExpression)(unsafe.Pointer(n)).Clone(f) + case KindVoidKeyword, KindAnyKeyword, KindBooleanKeyword, KindIntrinsicKeyword, KindNeverKeyword, KindNumberKeyword, KindObjectKeyword, KindStringKeyword, KindSymbolKeyword, KindUndefinedKeyword, KindUnknownKeyword, KindBigIntKeyword: + return (*KeywordTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindQualifiedName: + return (*QualifiedName)(unsafe.Pointer(n)).Clone(f) + case KindComputedPropertyName: + return (*ComputedPropertyName)(unsafe.Pointer(n)).Clone(f) + case KindDecorator: + return (*Decorator)(unsafe.Pointer(n)).Clone(f) + case KindEmptyStatement: + return (*EmptyStatement)(unsafe.Pointer(n)).Clone(f) + case KindIfStatement: + return (*IfStatement)(unsafe.Pointer(n)).Clone(f) + case KindDoStatement: + return (*DoStatement)(unsafe.Pointer(n)).Clone(f) + case KindWhileStatement: + return (*WhileStatement)(unsafe.Pointer(n)).Clone(f) + case KindForStatement: + return (*ForStatement)(unsafe.Pointer(n)).Clone(f) + case KindForInStatement, KindForOfStatement: + return (*ForInOrOfStatement)(unsafe.Pointer(n)).Clone(f) + case KindBreakStatement: + return (*BreakStatement)(unsafe.Pointer(n)).Clone(f) + case KindContinueStatement: + return (*ContinueStatement)(unsafe.Pointer(n)).Clone(f) + case KindReturnStatement: + return (*ReturnStatement)(unsafe.Pointer(n)).Clone(f) + case KindWithStatement: + return (*WithStatement)(unsafe.Pointer(n)).Clone(f) + case KindSwitchStatement: + return (*SwitchStatement)(unsafe.Pointer(n)).Clone(f) + case KindCaseBlock: + return (*CaseBlock)(unsafe.Pointer(n)).Clone(f) + case KindCaseClause, KindDefaultClause: + return (*CaseOrDefaultClause)(unsafe.Pointer(n)).Clone(f) + case KindThrowStatement: + return (*ThrowStatement)(unsafe.Pointer(n)).Clone(f) + case KindTryStatement: + return (*TryStatement)(unsafe.Pointer(n)).Clone(f) + case KindCatchClause: + return (*CatchClause)(unsafe.Pointer(n)).Clone(f) + case KindDebuggerStatement: + return (*DebuggerStatement)(unsafe.Pointer(n)).Clone(f) + case KindLabeledStatement: + return (*LabeledStatement)(unsafe.Pointer(n)).Clone(f) + case KindExpressionStatement: + return (*ExpressionStatement)(unsafe.Pointer(n)).Clone(f) + case KindBlock: + return (*Block)(unsafe.Pointer(n)).Clone(f) + case KindVariableStatement: + return (*VariableStatement)(unsafe.Pointer(n)).Clone(f) + case KindVariableDeclaration: + return (*VariableDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindVariableDeclarationList: + return (*VariableDeclarationList)(unsafe.Pointer(n)).Clone(f) + case KindObjectBindingPattern, KindArrayBindingPattern: + return (*BindingPattern)(unsafe.Pointer(n)).Clone(f) + case KindParameter: + return (*ParameterDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindBindingElement: + return (*BindingElement)(unsafe.Pointer(n)).Clone(f) + case KindMissingDeclaration: + return (*MissingDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindFunctionDeclaration: + return (*FunctionDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindClassDeclaration: + return (*ClassDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindClassExpression: + return (*ClassExpression)(unsafe.Pointer(n)).Clone(f) + case KindHeritageClause: + return (*HeritageClause)(unsafe.Pointer(n)).Clone(f) + case KindInterfaceDeclaration: + return (*InterfaceDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindTypeAliasDeclaration, KindJSTypeAliasDeclaration: + return (*TypeAliasDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindEnumMember: + return (*EnumMember)(unsafe.Pointer(n)).Clone(f) + case KindEnumDeclaration: + return (*EnumDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindModuleBlock: + return (*ModuleBlock)(unsafe.Pointer(n)).Clone(f) + case KindNotEmittedStatement: + return (*NotEmittedStatement)(unsafe.Pointer(n)).Clone(f) + case KindNotEmittedTypeElement: + return (*NotEmittedTypeElement)(unsafe.Pointer(n)).Clone(f) + case KindImportDeclaration, KindJSImportDeclaration: + return (*ImportDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindExternalModuleReference: + return (*ExternalModuleReference)(unsafe.Pointer(n)).Clone(f) + case KindNamespaceImport: + return (*NamespaceImport)(unsafe.Pointer(n)).Clone(f) + case KindNamedImports: + return (*NamedImports)(unsafe.Pointer(n)).Clone(f) + case KindExportAssignment: + return (*ExportAssignment)(unsafe.Pointer(n)).Clone(f) + case KindNamespaceExportDeclaration: + return (*NamespaceExportDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindNamespaceExport: + return (*NamespaceExport)(unsafe.Pointer(n)).Clone(f) + case KindNamedExports: + return (*NamedExports)(unsafe.Pointer(n)).Clone(f) + case KindExportSpecifier: + return (*ExportSpecifier)(unsafe.Pointer(n)).Clone(f) + case KindCallSignature: + return (*CallSignatureDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindConstructSignature: + return (*ConstructSignatureDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindConstructor: + return (*ConstructorDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindGetAccessor: + return (*GetAccessorDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindSetAccessor: + return (*SetAccessorDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindIndexSignature: + return (*IndexSignatureDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindMethodSignature: + return (*MethodSignatureDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindMethodDeclaration: + return (*MethodDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindPropertySignature: + return (*PropertySignatureDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindPropertyDeclaration: + return (*PropertyDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindSemicolonClassElement: + return (*SemicolonClassElement)(unsafe.Pointer(n)).Clone(f) + case KindClassStaticBlockDeclaration: + return (*ClassStaticBlockDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindOmittedExpression: + return (*OmittedExpression)(unsafe.Pointer(n)).Clone(f) + case KindBinaryExpression: + return (*BinaryExpression)(unsafe.Pointer(n)).Clone(f) + case KindPrefixUnaryExpression: + return (*PrefixUnaryExpression)(unsafe.Pointer(n)).Clone(f) + case KindPostfixUnaryExpression: + return (*PostfixUnaryExpression)(unsafe.Pointer(n)).Clone(f) + case KindYieldExpression: + return (*YieldExpression)(unsafe.Pointer(n)).Clone(f) + case KindArrowFunction: + return (*ArrowFunction)(unsafe.Pointer(n)).Clone(f) + case KindFunctionExpression: + return (*FunctionExpression)(unsafe.Pointer(n)).Clone(f) + case KindAsExpression: + return (*AsExpression)(unsafe.Pointer(n)).Clone(f) + case KindSatisfiesExpression: + return (*SatisfiesExpression)(unsafe.Pointer(n)).Clone(f) + case KindConditionalExpression: + return (*ConditionalExpression)(unsafe.Pointer(n)).Clone(f) + case KindPropertyAccessExpression: + return (*PropertyAccessExpression)(unsafe.Pointer(n)).Clone(f) + case KindElementAccessExpression: + return (*ElementAccessExpression)(unsafe.Pointer(n)).Clone(f) + case KindCallExpression: + return (*CallExpression)(unsafe.Pointer(n)).Clone(f) + case KindNewExpression: + return (*NewExpression)(unsafe.Pointer(n)).Clone(f) + case KindMetaProperty: + return (*MetaProperty)(unsafe.Pointer(n)).Clone(f) + case KindNonNullExpression: + return (*NonNullExpression)(unsafe.Pointer(n)).Clone(f) + case KindSpreadElement: + return (*SpreadElement)(unsafe.Pointer(n)).Clone(f) + case KindTemplateExpression: + return (*TemplateExpression)(unsafe.Pointer(n)).Clone(f) + case KindTemplateSpan: + return (*TemplateSpan)(unsafe.Pointer(n)).Clone(f) + case KindTaggedTemplateExpression: + return (*TaggedTemplateExpression)(unsafe.Pointer(n)).Clone(f) + case KindParenthesizedExpression: + return (*ParenthesizedExpression)(unsafe.Pointer(n)).Clone(f) + case KindArrayLiteralExpression: + return (*ArrayLiteralExpression)(unsafe.Pointer(n)).Clone(f) + case KindObjectLiteralExpression: + return (*ObjectLiteralExpression)(unsafe.Pointer(n)).Clone(f) + case KindSpreadAssignment: + return (*SpreadAssignment)(unsafe.Pointer(n)).Clone(f) + case KindPropertyAssignment: + return (*PropertyAssignment)(unsafe.Pointer(n)).Clone(f) + case KindShorthandPropertyAssignment: + return (*ShorthandPropertyAssignment)(unsafe.Pointer(n)).Clone(f) + case KindDeleteExpression: + return (*DeleteExpression)(unsafe.Pointer(n)).Clone(f) + case KindTypeOfExpression: + return (*TypeOfExpression)(unsafe.Pointer(n)).Clone(f) + case KindVoidExpression: + return (*VoidExpression)(unsafe.Pointer(n)).Clone(f) + case KindAwaitExpression: + return (*AwaitExpression)(unsafe.Pointer(n)).Clone(f) + case KindTypeAssertionExpression: + return (*TypeAssertion)(unsafe.Pointer(n)).Clone(f) + case KindUnionType: + return (*UnionTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindIntersectionType: + return (*IntersectionTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindConditionalType: + return (*ConditionalTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindTypeOperator: + return (*TypeOperatorNode)(unsafe.Pointer(n)).Clone(f) + case KindInferType: + return (*InferTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindArrayType: + return (*ArrayTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindIndexedAccessType: + return (*IndexedAccessTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindTypeReference: + return (*TypeReferenceNode)(unsafe.Pointer(n)).Clone(f) + case KindExpressionWithTypeArguments: + return (*ExpressionWithTypeArguments)(unsafe.Pointer(n)).Clone(f) + case KindLiteralType: + return (*LiteralTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindThisType: + return (*ThisTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindTypePredicate: + return (*TypePredicateNode)(unsafe.Pointer(n)).Clone(f) + case KindImportAttribute: + return (*ImportAttribute)(unsafe.Pointer(n)).Clone(f) + case KindImportAttributes: + return (*ImportAttributes)(unsafe.Pointer(n)).Clone(f) + case KindTypeQuery: + return (*TypeQueryNode)(unsafe.Pointer(n)).Clone(f) + case KindMappedType: + return (*MappedTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindTypeLiteral: + return (*TypeLiteralNode)(unsafe.Pointer(n)).Clone(f) + case KindTupleType: + return (*TupleTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindNamedTupleMember: + return (*NamedTupleMember)(unsafe.Pointer(n)).Clone(f) + case KindOptionalType: + return (*OptionalTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindRestType: + return (*RestTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindParenthesizedType: + return (*ParenthesizedTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindFunctionType: + return (*FunctionTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindConstructorType: + return (*ConstructorTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindTemplateLiteralType: + return (*TemplateLiteralTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindTemplateLiteralTypeSpan: + return (*TemplateLiteralTypeSpan)(unsafe.Pointer(n)).Clone(f) + case KindSyntheticExpression: + return (*SyntheticExpression)(unsafe.Pointer(n)).Clone(f) + case KindPartiallyEmittedExpression: + return (*PartiallyEmittedExpression)(unsafe.Pointer(n)).Clone(f) + case KindJsxElement: + return (*JsxElement)(unsafe.Pointer(n)).Clone(f) + case KindJsxAttributes: + return (*JsxAttributes)(unsafe.Pointer(n)).Clone(f) + case KindJsxNamespacedName: + return (*JsxNamespacedName)(unsafe.Pointer(n)).Clone(f) + case KindJsxOpeningElement: + return (*JsxOpeningElement)(unsafe.Pointer(n)).Clone(f) + case KindJsxSelfClosingElement: + return (*JsxSelfClosingElement)(unsafe.Pointer(n)).Clone(f) + case KindJsxFragment: + return (*JsxFragment)(unsafe.Pointer(n)).Clone(f) + case KindJsxOpeningFragment: + return (*JsxOpeningFragment)(unsafe.Pointer(n)).Clone(f) + case KindJsxClosingFragment: + return (*JsxClosingFragment)(unsafe.Pointer(n)).Clone(f) + case KindJsxAttribute: + return (*JsxAttribute)(unsafe.Pointer(n)).Clone(f) + case KindJsxSpreadAttribute: + return (*JsxSpreadAttribute)(unsafe.Pointer(n)).Clone(f) + case KindJsxClosingElement: + return (*JsxClosingElement)(unsafe.Pointer(n)).Clone(f) + case KindJsxExpression: + return (*JsxExpression)(unsafe.Pointer(n)).Clone(f) + case KindSyntaxList: + return (*SyntaxList)(unsafe.Pointer(n)).Clone(f) + case KindJSDoc: + return (*JSDoc)(unsafe.Pointer(n)).Clone(f) + case KindJSDocTypeExpression: + return (*JSDocTypeExpression)(unsafe.Pointer(n)).Clone(f) + case KindJSDocNonNullableType: + return (*JSDocNonNullableType)(unsafe.Pointer(n)).Clone(f) + case KindJSDocNullableType: + return (*JSDocNullableType)(unsafe.Pointer(n)).Clone(f) + case KindJSDocAllType: + return (*JSDocAllType)(unsafe.Pointer(n)).Clone(f) + case KindJSDocVariadicType: + return (*JSDocVariadicType)(unsafe.Pointer(n)).Clone(f) + case KindJSDocOptionalType: + return (*JSDocOptionalType)(unsafe.Pointer(n)).Clone(f) + case KindJSDocTypeTag: + return (*JSDocTypeTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocUnknownTag: + return (*JSDocUnknownTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocTemplateTag: + return (*JSDocTemplateTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocReturnTag: + return (*JSDocReturnTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocPublicTag: + return (*JSDocPublicTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocPrivateTag: + return (*JSDocPrivateTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocProtectedTag: + return (*JSDocProtectedTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocReadonlyTag: + return (*JSDocReadonlyTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocOverrideTag: + return (*JSDocOverrideTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocDeprecatedTag: + return (*JSDocDeprecatedTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocSeeTag: + return (*JSDocSeeTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocImplementsTag: + return (*JSDocImplementsTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocAugmentsTag: + return (*JSDocAugmentsTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocSatisfiesTag: + return (*JSDocSatisfiesTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocThrowsTag: + return (*JSDocThrowsTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocThisTag: + return (*JSDocThisTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocImportTag: + return (*JSDocImportTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocCallbackTag: + return (*JSDocCallbackTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocOverloadTag: + return (*JSDocOverloadTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocTypedefTag: + return (*JSDocTypedefTag)(unsafe.Pointer(n)).Clone(f) + case KindJSDocSignature: + return (*JSDocSignature)(unsafe.Pointer(n)).Clone(f) + case KindJSDocNameReference: + return (*JSDocNameReference)(unsafe.Pointer(n)).Clone(f) + case KindSourceFile: + return (*SourceFile)(unsafe.Pointer(n)).Clone(f) + case KindModuleDeclaration: + return (*ModuleDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindImportEqualsDeclaration: + return (*ImportEqualsDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindExportDeclaration: + return (*ExportDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindImportType: + return (*ImportTypeNode)(unsafe.Pointer(n)).Clone(f) + case KindImportClause: + return (*ImportClause)(unsafe.Pointer(n)).Clone(f) + case KindImportSpecifier: + return (*ImportSpecifier)(unsafe.Pointer(n)).Clone(f) + case KindJSDocText: + return (*JSDocText)(unsafe.Pointer(n)).Clone(f) + case KindJSDocLink: + return (*JSDocLink)(unsafe.Pointer(n)).Clone(f) + case KindJSDocLinkPlain: + return (*JSDocLinkPlain)(unsafe.Pointer(n)).Clone(f) + case KindJSDocLinkCode: + return (*JSDocLinkCode)(unsafe.Pointer(n)).Clone(f) + case KindTypeParameter: + return (*TypeParameterDeclaration)(unsafe.Pointer(n)).Clone(f) + case KindSyntheticReferenceExpression: + return (*SyntheticReferenceExpression)(unsafe.Pointer(n)).Clone(f) + case KindJSDocTypeLiteral: + return (*JSDocTypeLiteral)(unsafe.Pointer(n)).Clone(f) + case KindJSDocParameterTag, KindJSDocPropertyTag: + return (*JSDocParameterOrPropertyTag)(unsafe.Pointer(n)).Clone(f) + default: + panic("Unhandled case in Node.Clone: " + n.Kind.String()) + } +} + +func (n *MutableNode) SetModifiers(modifiers *ModifierList) { + node := (*Node)(unsafe.Pointer(n)) + kind := uint16(node.Kind) + if kind >= uint16(len(nodeModifiersOffsets)) { + panic("Cannot set modifiers on " + node.Kind.String()) + } + offset := nodeModifiersOffsets[kind] + if offset == 0 { + panic("Cannot set modifiers on " + node.Kind.String()) + } + *(**ModifierList)(unsafe.Add(unsafe.Pointer(node), uintptr(offset-1))) = modifiers +} + +// ────────────────────────────────────────────────────────────────────── +// As*() cast methods +// ────────────────────────────────────────────────────────────────────── + +func (n *Node) AsToken() *Token { + switch n.Kind { + case KindUnknown, KindEndOfFile, KindSingleLineCommentTrivia, KindMultiLineCommentTrivia, KindNewLineTrivia, KindWhitespaceTrivia, KindConflictMarkerTrivia, KindNonTextFileMarkerTrivia, KindJsxTextAllWhiteSpaces, KindOpenBraceToken, KindCloseBraceToken, KindOpenParenToken, KindCloseParenToken, KindOpenBracketToken, KindCloseBracketToken, KindDotToken, KindDotDotDotToken, KindSemicolonToken, KindCommaToken, KindQuestionDotToken, KindLessThanToken, KindLessThanSlashToken, KindGreaterThanToken, KindLessThanEqualsToken, KindGreaterThanEqualsToken, KindEqualsEqualsToken, KindExclamationEqualsToken, KindEqualsEqualsEqualsToken, KindExclamationEqualsEqualsToken, KindEqualsGreaterThanToken, KindPlusToken, KindMinusToken, KindAsteriskToken, KindAsteriskAsteriskToken, KindSlashToken, KindPercentToken, KindPlusPlusToken, KindMinusMinusToken, KindLessThanLessThanToken, KindGreaterThanGreaterThanToken, KindGreaterThanGreaterThanGreaterThanToken, KindAmpersandToken, KindBarToken, KindCaretToken, KindExclamationToken, KindTildeToken, KindAmpersandAmpersandToken, KindBarBarToken, KindQuestionToken, KindColonToken, KindAtToken, KindQuestionQuestionToken, KindBacktickToken, KindHashToken, KindEqualsToken, KindPlusEqualsToken, KindMinusEqualsToken, KindAsteriskEqualsToken, KindAsteriskAsteriskEqualsToken, KindSlashEqualsToken, KindPercentEqualsToken, KindLessThanLessThanEqualsToken, KindGreaterThanGreaterThanEqualsToken, KindGreaterThanGreaterThanGreaterThanEqualsToken, KindAmpersandEqualsToken, KindBarEqualsToken, KindBarBarEqualsToken, KindAmpersandAmpersandEqualsToken, KindQuestionQuestionEqualsToken, KindCaretEqualsToken, KindJSDocCommentTextToken, KindBreakKeyword, KindCaseKeyword, KindCatchKeyword, KindClassKeyword, KindConstKeyword, KindContinueKeyword, KindDebuggerKeyword, KindDefaultKeyword, KindDeleteKeyword, KindDoKeyword, KindElseKeyword, KindEnumKeyword, KindExportKeyword, KindExtendsKeyword, KindFinallyKeyword, KindForKeyword, KindFunctionKeyword, KindIfKeyword, KindInKeyword, KindInstanceOfKeyword, KindNewKeyword, KindReturnKeyword, KindSwitchKeyword, KindThrowKeyword, KindTryKeyword, KindTypeOfKeyword, KindVarKeyword, KindWhileKeyword, KindWithKeyword, KindImplementsKeyword, KindInterfaceKeyword, KindLetKeyword, KindPackageKeyword, KindPrivateKeyword, KindProtectedKeyword, KindPublicKeyword, KindStaticKeyword, KindYieldKeyword, KindAbstractKeyword, KindAccessorKeyword, KindAsKeyword, KindAssertsKeyword, KindAssertKeyword, KindAsyncKeyword, KindAwaitKeyword, KindConstructorKeyword, KindDeclareKeyword, KindGetKeyword, KindImmediateKeyword, KindInferKeyword, KindIsKeyword, KindKeyOfKeyword, KindModuleKeyword, KindNamespaceKeyword, KindOutKeyword, KindReadonlyKeyword, KindRequireKeyword, KindSatisfiesKeyword, KindSetKeyword, KindTypeKeyword, KindUniqueKeyword, KindUsingKeyword, KindFromKeyword, KindGlobalKeyword, KindOverrideKeyword, KindOfKeyword, KindDeferKeyword: + return (*Token)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to Token") + } +} + +func (n *Node) AsIdentifier() *Identifier { + switch n.Kind { + case KindIdentifier: + return (*Identifier)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to Identifier") + } +} + +func (n *Node) AsPrivateIdentifier() *PrivateIdentifier { + switch n.Kind { + case KindPrivateIdentifier: + return (*PrivateIdentifier)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to PrivateIdentifier") + } +} + +func (n *Node) AsQualifiedName() *QualifiedName { + switch n.Kind { + case KindQualifiedName: + return (*QualifiedName)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to QualifiedName") + } +} + +func (n *Node) AsComputedPropertyName() *ComputedPropertyName { + switch n.Kind { + case KindComputedPropertyName: + return (*ComputedPropertyName)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ComputedPropertyName") + } +} + +func (n *Node) AsDecorator() *Decorator { + switch n.Kind { + case KindDecorator: + return (*Decorator)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to Decorator") + } +} + +func (n *Node) AsEmptyStatement() *EmptyStatement { + switch n.Kind { + case KindEmptyStatement: + return (*EmptyStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to EmptyStatement") + } +} + +func (n *Node) AsIfStatement() *IfStatement { + switch n.Kind { + case KindIfStatement: + return (*IfStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to IfStatement") + } +} + +func (n *Node) AsDoStatement() *DoStatement { + switch n.Kind { + case KindDoStatement: + return (*DoStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to DoStatement") + } +} + +func (n *Node) AsWhileStatement() *WhileStatement { + switch n.Kind { + case KindWhileStatement: + return (*WhileStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to WhileStatement") + } +} + +func (n *Node) AsForStatement() *ForStatement { + switch n.Kind { + case KindForStatement: + return (*ForStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ForStatement") + } +} + +func (n *Node) AsForInOrOfStatement() *ForInOrOfStatement { + switch n.Kind { + case KindForInStatement, KindForOfStatement: + return (*ForInOrOfStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ForInOrOfStatement") + } +} + +func (n *Node) AsBreakStatement() *BreakStatement { + switch n.Kind { + case KindBreakStatement: + return (*BreakStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to BreakStatement") + } +} + +func (n *Node) AsContinueStatement() *ContinueStatement { + switch n.Kind { + case KindContinueStatement: + return (*ContinueStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ContinueStatement") + } +} + +func (n *Node) AsReturnStatement() *ReturnStatement { + switch n.Kind { + case KindReturnStatement: + return (*ReturnStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ReturnStatement") + } +} + +func (n *Node) AsWithStatement() *WithStatement { + switch n.Kind { + case KindWithStatement: + return (*WithStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to WithStatement") + } +} + +func (n *Node) AsSwitchStatement() *SwitchStatement { + switch n.Kind { + case KindSwitchStatement: + return (*SwitchStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SwitchStatement") + } +} + +func (n *Node) AsCaseBlock() *CaseBlock { + switch n.Kind { + case KindCaseBlock: + return (*CaseBlock)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to CaseBlock") + } +} + +func (n *Node) AsCaseOrDefaultClause() *CaseOrDefaultClause { + switch n.Kind { + case KindCaseClause, KindDefaultClause: + return (*CaseOrDefaultClause)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to CaseOrDefaultClause") + } +} + +func (n *Node) AsThrowStatement() *ThrowStatement { + switch n.Kind { + case KindThrowStatement: + return (*ThrowStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ThrowStatement") + } +} + +func (n *Node) AsTryStatement() *TryStatement { + switch n.Kind { + case KindTryStatement: + return (*TryStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TryStatement") + } +} + +func (n *Node) AsCatchClause() *CatchClause { + switch n.Kind { + case KindCatchClause: + return (*CatchClause)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to CatchClause") + } +} + +func (n *Node) AsDebuggerStatement() *DebuggerStatement { + switch n.Kind { + case KindDebuggerStatement: + return (*DebuggerStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to DebuggerStatement") + } +} + +func (n *Node) AsLabeledStatement() *LabeledStatement { + switch n.Kind { + case KindLabeledStatement: + return (*LabeledStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to LabeledStatement") + } +} + +func (n *Node) AsExpressionStatement() *ExpressionStatement { + switch n.Kind { + case KindExpressionStatement: + return (*ExpressionStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ExpressionStatement") + } +} + +func (n *Node) AsBlock() *Block { + switch n.Kind { + case KindBlock: + return (*Block)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to Block") + } +} + +func (n *Node) AsVariableStatement() *VariableStatement { + switch n.Kind { + case KindVariableStatement: + return (*VariableStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to VariableStatement") + } +} + +func (n *Node) AsVariableDeclaration() *VariableDeclaration { + switch n.Kind { + case KindVariableDeclaration: + return (*VariableDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to VariableDeclaration") + } +} func (n *Node) AsVariableDeclarationList() *VariableDeclarationList { - return n.data.(*VariableDeclarationList) + switch n.Kind { + case KindVariableDeclarationList: + return (*VariableDeclarationList)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to VariableDeclarationList") + } } func (n *Node) AsBindingPattern() *BindingPattern { - return n.data.(*BindingPattern) + switch n.Kind { + case KindObjectBindingPattern, KindArrayBindingPattern: + return (*BindingPattern)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to BindingPattern") + } } func (n *Node) AsParameterDeclaration() *ParameterDeclaration { - return n.data.(*ParameterDeclaration) + switch n.Kind { + case KindParameter: + return (*ParameterDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ParameterDeclaration") + } } func (n *Node) AsBindingElement() *BindingElement { - return n.data.(*BindingElement) + switch n.Kind { + case KindBindingElement: + return (*BindingElement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to BindingElement") + } } func (n *Node) AsMissingDeclaration() *MissingDeclaration { - return n.data.(*MissingDeclaration) + switch n.Kind { + case KindMissingDeclaration: + return (*MissingDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to MissingDeclaration") + } } func (n *Node) AsFunctionDeclaration() *FunctionDeclaration { - return n.data.(*FunctionDeclaration) + switch n.Kind { + case KindFunctionDeclaration: + return (*FunctionDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to FunctionDeclaration") + } } func (n *Node) AsClassDeclaration() *ClassDeclaration { - return n.data.(*ClassDeclaration) + switch n.Kind { + case KindClassDeclaration: + return (*ClassDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ClassDeclaration") + } } func (n *Node) AsClassExpression() *ClassExpression { - return n.data.(*ClassExpression) + switch n.Kind { + case KindClassExpression: + return (*ClassExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ClassExpression") + } } func (n *Node) AsHeritageClause() *HeritageClause { - return n.data.(*HeritageClause) + switch n.Kind { + case KindHeritageClause: + return (*HeritageClause)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to HeritageClause") + } } func (n *Node) AsInterfaceDeclaration() *InterfaceDeclaration { - return n.data.(*InterfaceDeclaration) + switch n.Kind { + case KindInterfaceDeclaration: + return (*InterfaceDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to InterfaceDeclaration") + } } func (n *Node) AsTypeAliasDeclaration() *TypeAliasDeclaration { - return n.data.(*TypeAliasDeclaration) + switch n.Kind { + case KindTypeAliasDeclaration, KindJSTypeAliasDeclaration: + return (*TypeAliasDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TypeAliasDeclaration") + } } func (n *Node) AsEnumMember() *EnumMember { - return n.data.(*EnumMember) + switch n.Kind { + case KindEnumMember: + return (*EnumMember)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to EnumMember") + } } func (n *Node) AsEnumDeclaration() *EnumDeclaration { - return n.data.(*EnumDeclaration) + switch n.Kind { + case KindEnumDeclaration: + return (*EnumDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to EnumDeclaration") + } } func (n *Node) AsModuleBlock() *ModuleBlock { - return n.data.(*ModuleBlock) + switch n.Kind { + case KindModuleBlock: + return (*ModuleBlock)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ModuleBlock") + } } func (n *Node) AsNotEmittedStatement() *NotEmittedStatement { - return n.data.(*NotEmittedStatement) + switch n.Kind { + case KindNotEmittedStatement: + return (*NotEmittedStatement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NotEmittedStatement") + } } func (n *Node) AsNotEmittedTypeElement() *NotEmittedTypeElement { - return n.data.(*NotEmittedTypeElement) + switch n.Kind { + case KindNotEmittedTypeElement: + return (*NotEmittedTypeElement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NotEmittedTypeElement") + } } func (n *Node) AsImportDeclaration() *ImportDeclaration { - return n.data.(*ImportDeclaration) + switch n.Kind { + case KindImportDeclaration, KindJSImportDeclaration: + return (*ImportDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ImportDeclaration") + } } func (n *Node) AsExternalModuleReference() *ExternalModuleReference { - return n.data.(*ExternalModuleReference) + switch n.Kind { + case KindExternalModuleReference: + return (*ExternalModuleReference)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ExternalModuleReference") + } } func (n *Node) AsNamespaceImport() *NamespaceImport { - return n.data.(*NamespaceImport) + switch n.Kind { + case KindNamespaceImport: + return (*NamespaceImport)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NamespaceImport") + } } func (n *Node) AsNamedImports() *NamedImports { - return n.data.(*NamedImports) + switch n.Kind { + case KindNamedImports: + return (*NamedImports)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NamedImports") + } } func (n *Node) AsExportAssignment() *ExportAssignment { - return n.data.(*ExportAssignment) + switch n.Kind { + case KindExportAssignment: + return (*ExportAssignment)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ExportAssignment") + } } func (n *Node) AsNamespaceExportDeclaration() *NamespaceExportDeclaration { - return n.data.(*NamespaceExportDeclaration) + switch n.Kind { + case KindNamespaceExportDeclaration: + return (*NamespaceExportDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NamespaceExportDeclaration") + } } func (n *Node) AsNamespaceExport() *NamespaceExport { - return n.data.(*NamespaceExport) + switch n.Kind { + case KindNamespaceExport: + return (*NamespaceExport)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NamespaceExport") + } } func (n *Node) AsNamedExports() *NamedExports { - return n.data.(*NamedExports) + switch n.Kind { + case KindNamedExports: + return (*NamedExports)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NamedExports") + } } func (n *Node) AsExportSpecifier() *ExportSpecifier { - return n.data.(*ExportSpecifier) + switch n.Kind { + case KindExportSpecifier: + return (*ExportSpecifier)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ExportSpecifier") + } } func (n *Node) AsCallSignatureDeclaration() *CallSignatureDeclaration { - return n.data.(*CallSignatureDeclaration) + switch n.Kind { + case KindCallSignature: + return (*CallSignatureDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to CallSignatureDeclaration") + } } func (n *Node) AsConstructSignatureDeclaration() *ConstructSignatureDeclaration { - return n.data.(*ConstructSignatureDeclaration) + switch n.Kind { + case KindConstructSignature: + return (*ConstructSignatureDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ConstructSignatureDeclaration") + } } func (n *Node) AsConstructorDeclaration() *ConstructorDeclaration { - return n.data.(*ConstructorDeclaration) + switch n.Kind { + case KindConstructor: + return (*ConstructorDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ConstructorDeclaration") + } } func (n *Node) AsGetAccessorDeclaration() *GetAccessorDeclaration { - return n.data.(*GetAccessorDeclaration) + switch n.Kind { + case KindGetAccessor: + return (*GetAccessorDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to GetAccessorDeclaration") + } } func (n *Node) AsSetAccessorDeclaration() *SetAccessorDeclaration { - return n.data.(*SetAccessorDeclaration) + switch n.Kind { + case KindSetAccessor: + return (*SetAccessorDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SetAccessorDeclaration") + } } func (n *Node) AsIndexSignatureDeclaration() *IndexSignatureDeclaration { - return n.data.(*IndexSignatureDeclaration) + switch n.Kind { + case KindIndexSignature: + return (*IndexSignatureDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to IndexSignatureDeclaration") + } } func (n *Node) AsMethodSignatureDeclaration() *MethodSignatureDeclaration { - return n.data.(*MethodSignatureDeclaration) + switch n.Kind { + case KindMethodSignature: + return (*MethodSignatureDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to MethodSignatureDeclaration") + } } func (n *Node) AsMethodDeclaration() *MethodDeclaration { - return n.data.(*MethodDeclaration) + switch n.Kind { + case KindMethodDeclaration: + return (*MethodDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to MethodDeclaration") + } } func (n *Node) AsPropertySignatureDeclaration() *PropertySignatureDeclaration { - return n.data.(*PropertySignatureDeclaration) + switch n.Kind { + case KindPropertySignature: + return (*PropertySignatureDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to PropertySignatureDeclaration") + } } func (n *Node) AsPropertyDeclaration() *PropertyDeclaration { - return n.data.(*PropertyDeclaration) + switch n.Kind { + case KindPropertyDeclaration: + return (*PropertyDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to PropertyDeclaration") + } } func (n *Node) AsSemicolonClassElement() *SemicolonClassElement { - return n.data.(*SemicolonClassElement) + switch n.Kind { + case KindSemicolonClassElement: + return (*SemicolonClassElement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SemicolonClassElement") + } } func (n *Node) AsClassStaticBlockDeclaration() *ClassStaticBlockDeclaration { - return n.data.(*ClassStaticBlockDeclaration) + switch n.Kind { + case KindClassStaticBlockDeclaration: + return (*ClassStaticBlockDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ClassStaticBlockDeclaration") + } } func (n *Node) AsOmittedExpression() *OmittedExpression { - return n.data.(*OmittedExpression) + switch n.Kind { + case KindOmittedExpression: + return (*OmittedExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to OmittedExpression") + } } func (n *Node) AsKeywordExpression() *KeywordExpression { - return n.data.(*KeywordExpression) + switch n.Kind { + case KindFalseKeyword, KindImportKeyword, KindNullKeyword, KindSuperKeyword, KindThisKeyword, KindTrueKeyword: + return (*KeywordExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to KeywordExpression") + } } func (n *Node) AsStringLiteral() *StringLiteral { - return n.data.(*StringLiteral) + switch n.Kind { + case KindStringLiteral: + return (*StringLiteral)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to StringLiteral") + } } func (n *Node) AsNumericLiteral() *NumericLiteral { - return n.data.(*NumericLiteral) + switch n.Kind { + case KindNumericLiteral: + return (*NumericLiteral)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NumericLiteral") + } } func (n *Node) AsBigIntLiteral() *BigIntLiteral { - return n.data.(*BigIntLiteral) + switch n.Kind { + case KindBigIntLiteral: + return (*BigIntLiteral)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to BigIntLiteral") + } } func (n *Node) AsRegularExpressionLiteral() *RegularExpressionLiteral { - return n.data.(*RegularExpressionLiteral) + switch n.Kind { + case KindRegularExpressionLiteral: + return (*RegularExpressionLiteral)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to RegularExpressionLiteral") + } } func (n *Node) AsNoSubstitutionTemplateLiteral() *NoSubstitutionTemplateLiteral { - return n.data.(*NoSubstitutionTemplateLiteral) + switch n.Kind { + case KindNoSubstitutionTemplateLiteral: + return (*NoSubstitutionTemplateLiteral)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NoSubstitutionTemplateLiteral") + } } func (n *Node) AsBinaryExpression() *BinaryExpression { - return n.data.(*BinaryExpression) + switch n.Kind { + case KindBinaryExpression: + return (*BinaryExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to BinaryExpression") + } } func (n *Node) AsPrefixUnaryExpression() *PrefixUnaryExpression { - return n.data.(*PrefixUnaryExpression) + switch n.Kind { + case KindPrefixUnaryExpression: + return (*PrefixUnaryExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to PrefixUnaryExpression") + } } func (n *Node) AsPostfixUnaryExpression() *PostfixUnaryExpression { - return n.data.(*PostfixUnaryExpression) + switch n.Kind { + case KindPostfixUnaryExpression: + return (*PostfixUnaryExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to PostfixUnaryExpression") + } } func (n *Node) AsYieldExpression() *YieldExpression { - return n.data.(*YieldExpression) + switch n.Kind { + case KindYieldExpression: + return (*YieldExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to YieldExpression") + } } func (n *Node) AsArrowFunction() *ArrowFunction { - return n.data.(*ArrowFunction) + switch n.Kind { + case KindArrowFunction: + return (*ArrowFunction)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ArrowFunction") + } } func (n *Node) AsFunctionExpression() *FunctionExpression { - return n.data.(*FunctionExpression) + switch n.Kind { + case KindFunctionExpression: + return (*FunctionExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to FunctionExpression") + } } func (n *Node) AsAsExpression() *AsExpression { - return n.data.(*AsExpression) + switch n.Kind { + case KindAsExpression: + return (*AsExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to AsExpression") + } } func (n *Node) AsSatisfiesExpression() *SatisfiesExpression { - return n.data.(*SatisfiesExpression) + switch n.Kind { + case KindSatisfiesExpression: + return (*SatisfiesExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SatisfiesExpression") + } } func (n *Node) AsConditionalExpression() *ConditionalExpression { - return n.data.(*ConditionalExpression) + switch n.Kind { + case KindConditionalExpression: + return (*ConditionalExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ConditionalExpression") + } } func (n *Node) AsPropertyAccessExpression() *PropertyAccessExpression { - return n.data.(*PropertyAccessExpression) + switch n.Kind { + case KindPropertyAccessExpression: + return (*PropertyAccessExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to PropertyAccessExpression") + } } func (n *Node) AsElementAccessExpression() *ElementAccessExpression { - return n.data.(*ElementAccessExpression) + switch n.Kind { + case KindElementAccessExpression: + return (*ElementAccessExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ElementAccessExpression") + } } func (n *Node) AsCallExpression() *CallExpression { - return n.data.(*CallExpression) + switch n.Kind { + case KindCallExpression: + return (*CallExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to CallExpression") + } } func (n *Node) AsNewExpression() *NewExpression { - return n.data.(*NewExpression) + switch n.Kind { + case KindNewExpression: + return (*NewExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NewExpression") + } } func (n *Node) AsMetaProperty() *MetaProperty { - return n.data.(*MetaProperty) + switch n.Kind { + case KindMetaProperty: + return (*MetaProperty)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to MetaProperty") + } } func (n *Node) AsNonNullExpression() *NonNullExpression { - return n.data.(*NonNullExpression) + switch n.Kind { + case KindNonNullExpression: + return (*NonNullExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NonNullExpression") + } } func (n *Node) AsSpreadElement() *SpreadElement { - return n.data.(*SpreadElement) + switch n.Kind { + case KindSpreadElement: + return (*SpreadElement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SpreadElement") + } } func (n *Node) AsTemplateExpression() *TemplateExpression { - return n.data.(*TemplateExpression) + switch n.Kind { + case KindTemplateExpression: + return (*TemplateExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TemplateExpression") + } } func (n *Node) AsTemplateSpan() *TemplateSpan { - return n.data.(*TemplateSpan) + switch n.Kind { + case KindTemplateSpan: + return (*TemplateSpan)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TemplateSpan") + } } func (n *Node) AsTaggedTemplateExpression() *TaggedTemplateExpression { - return n.data.(*TaggedTemplateExpression) + switch n.Kind { + case KindTaggedTemplateExpression: + return (*TaggedTemplateExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TaggedTemplateExpression") + } } func (n *Node) AsParenthesizedExpression() *ParenthesizedExpression { - return n.data.(*ParenthesizedExpression) + switch n.Kind { + case KindParenthesizedExpression: + return (*ParenthesizedExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ParenthesizedExpression") + } } func (n *Node) AsArrayLiteralExpression() *ArrayLiteralExpression { - return n.data.(*ArrayLiteralExpression) + switch n.Kind { + case KindArrayLiteralExpression: + return (*ArrayLiteralExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ArrayLiteralExpression") + } } func (n *Node) AsObjectLiteralExpression() *ObjectLiteralExpression { - return n.data.(*ObjectLiteralExpression) + switch n.Kind { + case KindObjectLiteralExpression: + return (*ObjectLiteralExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ObjectLiteralExpression") + } } func (n *Node) AsSpreadAssignment() *SpreadAssignment { - return n.data.(*SpreadAssignment) + switch n.Kind { + case KindSpreadAssignment: + return (*SpreadAssignment)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SpreadAssignment") + } } func (n *Node) AsPropertyAssignment() *PropertyAssignment { - return n.data.(*PropertyAssignment) + switch n.Kind { + case KindPropertyAssignment: + return (*PropertyAssignment)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to PropertyAssignment") + } } func (n *Node) AsShorthandPropertyAssignment() *ShorthandPropertyAssignment { - return n.data.(*ShorthandPropertyAssignment) + switch n.Kind { + case KindShorthandPropertyAssignment: + return (*ShorthandPropertyAssignment)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ShorthandPropertyAssignment") + } } func (n *Node) AsDeleteExpression() *DeleteExpression { - return n.data.(*DeleteExpression) + switch n.Kind { + case KindDeleteExpression: + return (*DeleteExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to DeleteExpression") + } } func (n *Node) AsTypeOfExpression() *TypeOfExpression { - return n.data.(*TypeOfExpression) + switch n.Kind { + case KindTypeOfExpression: + return (*TypeOfExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TypeOfExpression") + } } func (n *Node) AsVoidExpression() *VoidExpression { - return n.data.(*VoidExpression) + switch n.Kind { + case KindVoidExpression: + return (*VoidExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to VoidExpression") + } } func (n *Node) AsAwaitExpression() *AwaitExpression { - return n.data.(*AwaitExpression) + switch n.Kind { + case KindAwaitExpression: + return (*AwaitExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to AwaitExpression") + } } func (n *Node) AsTypeAssertion() *TypeAssertion { - return n.data.(*TypeAssertion) + switch n.Kind { + case KindTypeAssertionExpression: + return (*TypeAssertion)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TypeAssertion") + } } func (n *Node) AsKeywordTypeNode() *KeywordTypeNode { - return n.data.(*KeywordTypeNode) + switch n.Kind { + case KindVoidKeyword, KindAnyKeyword, KindBooleanKeyword, KindIntrinsicKeyword, KindNeverKeyword, KindNumberKeyword, KindObjectKeyword, KindStringKeyword, KindSymbolKeyword, KindUndefinedKeyword, KindUnknownKeyword, KindBigIntKeyword: + return (*KeywordTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to KeywordTypeNode") + } } func (n *Node) AsUnionTypeNode() *UnionTypeNode { - return n.data.(*UnionTypeNode) + switch n.Kind { + case KindUnionType: + return (*UnionTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to UnionTypeNode") + } } func (n *Node) AsIntersectionTypeNode() *IntersectionTypeNode { - return n.data.(*IntersectionTypeNode) + switch n.Kind { + case KindIntersectionType: + return (*IntersectionTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to IntersectionTypeNode") + } } func (n *Node) AsConditionalTypeNode() *ConditionalTypeNode { - return n.data.(*ConditionalTypeNode) + switch n.Kind { + case KindConditionalType: + return (*ConditionalTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ConditionalTypeNode") + } } func (n *Node) AsTypeOperatorNode() *TypeOperatorNode { - return n.data.(*TypeOperatorNode) + switch n.Kind { + case KindTypeOperator: + return (*TypeOperatorNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TypeOperatorNode") + } } func (n *Node) AsInferTypeNode() *InferTypeNode { - return n.data.(*InferTypeNode) + switch n.Kind { + case KindInferType: + return (*InferTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to InferTypeNode") + } } func (n *Node) AsArrayTypeNode() *ArrayTypeNode { - return n.data.(*ArrayTypeNode) + switch n.Kind { + case KindArrayType: + return (*ArrayTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ArrayTypeNode") + } } func (n *Node) AsIndexedAccessTypeNode() *IndexedAccessTypeNode { - return n.data.(*IndexedAccessTypeNode) + switch n.Kind { + case KindIndexedAccessType: + return (*IndexedAccessTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to IndexedAccessTypeNode") + } } func (n *Node) AsTypeReferenceNode() *TypeReferenceNode { - return n.data.(*TypeReferenceNode) + switch n.Kind { + case KindTypeReference: + return (*TypeReferenceNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TypeReferenceNode") + } } func (n *Node) AsExpressionWithTypeArguments() *ExpressionWithTypeArguments { - return n.data.(*ExpressionWithTypeArguments) + switch n.Kind { + case KindExpressionWithTypeArguments: + return (*ExpressionWithTypeArguments)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ExpressionWithTypeArguments") + } } func (n *Node) AsLiteralTypeNode() *LiteralTypeNode { - return n.data.(*LiteralTypeNode) + switch n.Kind { + case KindLiteralType: + return (*LiteralTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to LiteralTypeNode") + } } func (n *Node) AsThisTypeNode() *ThisTypeNode { - return n.data.(*ThisTypeNode) + switch n.Kind { + case KindThisType: + return (*ThisTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ThisTypeNode") + } } func (n *Node) AsTypePredicateNode() *TypePredicateNode { - return n.data.(*TypePredicateNode) + switch n.Kind { + case KindTypePredicate: + return (*TypePredicateNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TypePredicateNode") + } } func (n *Node) AsImportAttribute() *ImportAttribute { - return n.data.(*ImportAttribute) + switch n.Kind { + case KindImportAttribute: + return (*ImportAttribute)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ImportAttribute") + } } func (n *Node) AsImportAttributes() *ImportAttributes { - return n.data.(*ImportAttributes) + switch n.Kind { + case KindImportAttributes: + return (*ImportAttributes)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ImportAttributes") + } } func (n *Node) AsTypeQueryNode() *TypeQueryNode { - return n.data.(*TypeQueryNode) + switch n.Kind { + case KindTypeQuery: + return (*TypeQueryNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TypeQueryNode") + } } func (n *Node) AsMappedTypeNode() *MappedTypeNode { - return n.data.(*MappedTypeNode) + switch n.Kind { + case KindMappedType: + return (*MappedTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to MappedTypeNode") + } } func (n *Node) AsTypeLiteralNode() *TypeLiteralNode { - return n.data.(*TypeLiteralNode) + switch n.Kind { + case KindTypeLiteral: + return (*TypeLiteralNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TypeLiteralNode") + } } func (n *Node) AsTupleTypeNode() *TupleTypeNode { - return n.data.(*TupleTypeNode) + switch n.Kind { + case KindTupleType: + return (*TupleTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TupleTypeNode") + } } func (n *Node) AsNamedTupleMember() *NamedTupleMember { - return n.data.(*NamedTupleMember) + switch n.Kind { + case KindNamedTupleMember: + return (*NamedTupleMember)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to NamedTupleMember") + } } func (n *Node) AsOptionalTypeNode() *OptionalTypeNode { - return n.data.(*OptionalTypeNode) + switch n.Kind { + case KindOptionalType: + return (*OptionalTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to OptionalTypeNode") + } } func (n *Node) AsRestTypeNode() *RestTypeNode { - return n.data.(*RestTypeNode) + switch n.Kind { + case KindRestType: + return (*RestTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to RestTypeNode") + } } func (n *Node) AsParenthesizedTypeNode() *ParenthesizedTypeNode { - return n.data.(*ParenthesizedTypeNode) + switch n.Kind { + case KindParenthesizedType: + return (*ParenthesizedTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ParenthesizedTypeNode") + } } func (n *Node) AsFunctionTypeNode() *FunctionTypeNode { - return n.data.(*FunctionTypeNode) + switch n.Kind { + case KindFunctionType: + return (*FunctionTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to FunctionTypeNode") + } } func (n *Node) AsConstructorTypeNode() *ConstructorTypeNode { - return n.data.(*ConstructorTypeNode) + switch n.Kind { + case KindConstructorType: + return (*ConstructorTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ConstructorTypeNode") + } } func (n *Node) AsTemplateHead() *TemplateHead { - return n.data.(*TemplateHead) + switch n.Kind { + case KindTemplateHead: + return (*TemplateHead)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TemplateHead") + } } func (n *Node) AsTemplateMiddle() *TemplateMiddle { - return n.data.(*TemplateMiddle) + switch n.Kind { + case KindTemplateMiddle: + return (*TemplateMiddle)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TemplateMiddle") + } } func (n *Node) AsTemplateTail() *TemplateTail { - return n.data.(*TemplateTail) + switch n.Kind { + case KindTemplateTail: + return (*TemplateTail)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TemplateTail") + } } func (n *Node) AsTemplateLiteralTypeNode() *TemplateLiteralTypeNode { - return n.data.(*TemplateLiteralTypeNode) + switch n.Kind { + case KindTemplateLiteralType: + return (*TemplateLiteralTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TemplateLiteralTypeNode") + } } func (n *Node) AsTemplateLiteralTypeSpan() *TemplateLiteralTypeSpan { - return n.data.(*TemplateLiteralTypeSpan) + switch n.Kind { + case KindTemplateLiteralTypeSpan: + return (*TemplateLiteralTypeSpan)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TemplateLiteralTypeSpan") + } } func (n *Node) AsSyntheticExpression() *SyntheticExpression { - return n.data.(*SyntheticExpression) + switch n.Kind { + case KindSyntheticExpression: + return (*SyntheticExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SyntheticExpression") + } } func (n *Node) AsPartiallyEmittedExpression() *PartiallyEmittedExpression { - return n.data.(*PartiallyEmittedExpression) + switch n.Kind { + case KindPartiallyEmittedExpression: + return (*PartiallyEmittedExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to PartiallyEmittedExpression") + } } func (n *Node) AsJsxElement() *JsxElement { - return n.data.(*JsxElement) + switch n.Kind { + case KindJsxElement: + return (*JsxElement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxElement") + } } func (n *Node) AsJsxAttributes() *JsxAttributes { - return n.data.(*JsxAttributes) + switch n.Kind { + case KindJsxAttributes: + return (*JsxAttributes)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxAttributes") + } } func (n *Node) AsJsxNamespacedName() *JsxNamespacedName { - return n.data.(*JsxNamespacedName) + switch n.Kind { + case KindJsxNamespacedName: + return (*JsxNamespacedName)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxNamespacedName") + } } func (n *Node) AsJsxOpeningElement() *JsxOpeningElement { - return n.data.(*JsxOpeningElement) + switch n.Kind { + case KindJsxOpeningElement: + return (*JsxOpeningElement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxOpeningElement") + } } func (n *Node) AsJsxSelfClosingElement() *JsxSelfClosingElement { - return n.data.(*JsxSelfClosingElement) + switch n.Kind { + case KindJsxSelfClosingElement: + return (*JsxSelfClosingElement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxSelfClosingElement") + } } func (n *Node) AsJsxFragment() *JsxFragment { - return n.data.(*JsxFragment) + switch n.Kind { + case KindJsxFragment: + return (*JsxFragment)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxFragment") + } } func (n *Node) AsJsxOpeningFragment() *JsxOpeningFragment { - return n.data.(*JsxOpeningFragment) + switch n.Kind { + case KindJsxOpeningFragment: + return (*JsxOpeningFragment)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxOpeningFragment") + } } func (n *Node) AsJsxClosingFragment() *JsxClosingFragment { - return n.data.(*JsxClosingFragment) + switch n.Kind { + case KindJsxClosingFragment: + return (*JsxClosingFragment)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxClosingFragment") + } } func (n *Node) AsJsxAttribute() *JsxAttribute { - return n.data.(*JsxAttribute) + switch n.Kind { + case KindJsxAttribute: + return (*JsxAttribute)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxAttribute") + } } func (n *Node) AsJsxSpreadAttribute() *JsxSpreadAttribute { - return n.data.(*JsxSpreadAttribute) + switch n.Kind { + case KindJsxSpreadAttribute: + return (*JsxSpreadAttribute)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxSpreadAttribute") + } } func (n *Node) AsJsxClosingElement() *JsxClosingElement { - return n.data.(*JsxClosingElement) + switch n.Kind { + case KindJsxClosingElement: + return (*JsxClosingElement)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxClosingElement") + } } func (n *Node) AsJsxExpression() *JsxExpression { - return n.data.(*JsxExpression) + switch n.Kind { + case KindJsxExpression: + return (*JsxExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxExpression") + } } func (n *Node) AsJsxText() *JsxText { - return n.data.(*JsxText) + switch n.Kind { + case KindJsxText: + return (*JsxText)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JsxText") + } } func (n *Node) AsSyntaxList() *SyntaxList { - return n.data.(*SyntaxList) + switch n.Kind { + case KindSyntaxList: + return (*SyntaxList)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SyntaxList") + } } func (n *Node) AsJSDoc() *JSDoc { - return n.data.(*JSDoc) + switch n.Kind { + case KindJSDoc: + return (*JSDoc)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDoc") + } } func (n *Node) AsJSDocTypeExpression() *JSDocTypeExpression { - return n.data.(*JSDocTypeExpression) + switch n.Kind { + case KindJSDocTypeExpression: + return (*JSDocTypeExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocTypeExpression") + } } func (n *Node) AsJSDocNonNullableType() *JSDocNonNullableType { - return n.data.(*JSDocNonNullableType) + switch n.Kind { + case KindJSDocNonNullableType: + return (*JSDocNonNullableType)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocNonNullableType") + } } func (n *Node) AsJSDocNullableType() *JSDocNullableType { - return n.data.(*JSDocNullableType) + switch n.Kind { + case KindJSDocNullableType: + return (*JSDocNullableType)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocNullableType") + } } func (n *Node) AsJSDocAllType() *JSDocAllType { - return n.data.(*JSDocAllType) + switch n.Kind { + case KindJSDocAllType: + return (*JSDocAllType)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocAllType") + } } func (n *Node) AsJSDocVariadicType() *JSDocVariadicType { - return n.data.(*JSDocVariadicType) + switch n.Kind { + case KindJSDocVariadicType: + return (*JSDocVariadicType)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocVariadicType") + } } func (n *Node) AsJSDocOptionalType() *JSDocOptionalType { - return n.data.(*JSDocOptionalType) + switch n.Kind { + case KindJSDocOptionalType: + return (*JSDocOptionalType)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocOptionalType") + } } func (n *Node) AsJSDocTypeTag() *JSDocTypeTag { - return n.data.(*JSDocTypeTag) + switch n.Kind { + case KindJSDocTypeTag: + return (*JSDocTypeTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocTypeTag") + } } func (n *Node) AsJSDocUnknownTag() *JSDocUnknownTag { - return n.data.(*JSDocUnknownTag) + switch n.Kind { + case KindJSDocUnknownTag: + return (*JSDocUnknownTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocUnknownTag") + } } func (n *Node) AsJSDocTemplateTag() *JSDocTemplateTag { - return n.data.(*JSDocTemplateTag) + switch n.Kind { + case KindJSDocTemplateTag: + return (*JSDocTemplateTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocTemplateTag") + } } func (n *Node) AsJSDocReturnTag() *JSDocReturnTag { - return n.data.(*JSDocReturnTag) + switch n.Kind { + case KindJSDocReturnTag: + return (*JSDocReturnTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocReturnTag") + } } func (n *Node) AsJSDocPublicTag() *JSDocPublicTag { - return n.data.(*JSDocPublicTag) + switch n.Kind { + case KindJSDocPublicTag: + return (*JSDocPublicTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocPublicTag") + } } func (n *Node) AsJSDocPrivateTag() *JSDocPrivateTag { - return n.data.(*JSDocPrivateTag) + switch n.Kind { + case KindJSDocPrivateTag: + return (*JSDocPrivateTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocPrivateTag") + } } func (n *Node) AsJSDocProtectedTag() *JSDocProtectedTag { - return n.data.(*JSDocProtectedTag) + switch n.Kind { + case KindJSDocProtectedTag: + return (*JSDocProtectedTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocProtectedTag") + } } func (n *Node) AsJSDocReadonlyTag() *JSDocReadonlyTag { - return n.data.(*JSDocReadonlyTag) + switch n.Kind { + case KindJSDocReadonlyTag: + return (*JSDocReadonlyTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocReadonlyTag") + } } func (n *Node) AsJSDocOverrideTag() *JSDocOverrideTag { - return n.data.(*JSDocOverrideTag) + switch n.Kind { + case KindJSDocOverrideTag: + return (*JSDocOverrideTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocOverrideTag") + } } func (n *Node) AsJSDocDeprecatedTag() *JSDocDeprecatedTag { - return n.data.(*JSDocDeprecatedTag) + switch n.Kind { + case KindJSDocDeprecatedTag: + return (*JSDocDeprecatedTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocDeprecatedTag") + } } func (n *Node) AsJSDocSeeTag() *JSDocSeeTag { - return n.data.(*JSDocSeeTag) + switch n.Kind { + case KindJSDocSeeTag: + return (*JSDocSeeTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocSeeTag") + } } func (n *Node) AsJSDocImplementsTag() *JSDocImplementsTag { - return n.data.(*JSDocImplementsTag) + switch n.Kind { + case KindJSDocImplementsTag: + return (*JSDocImplementsTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocImplementsTag") + } } func (n *Node) AsJSDocAugmentsTag() *JSDocAugmentsTag { - return n.data.(*JSDocAugmentsTag) + switch n.Kind { + case KindJSDocAugmentsTag: + return (*JSDocAugmentsTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocAugmentsTag") + } } func (n *Node) AsJSDocSatisfiesTag() *JSDocSatisfiesTag { - return n.data.(*JSDocSatisfiesTag) + switch n.Kind { + case KindJSDocSatisfiesTag: + return (*JSDocSatisfiesTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocSatisfiesTag") + } } func (n *Node) AsJSDocThrowsTag() *JSDocThrowsTag { - return n.data.(*JSDocThrowsTag) + switch n.Kind { + case KindJSDocThrowsTag: + return (*JSDocThrowsTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocThrowsTag") + } } func (n *Node) AsJSDocThisTag() *JSDocThisTag { - return n.data.(*JSDocThisTag) + switch n.Kind { + case KindJSDocThisTag: + return (*JSDocThisTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocThisTag") + } } func (n *Node) AsJSDocImportTag() *JSDocImportTag { - return n.data.(*JSDocImportTag) + switch n.Kind { + case KindJSDocImportTag: + return (*JSDocImportTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocImportTag") + } } func (n *Node) AsJSDocCallbackTag() *JSDocCallbackTag { - return n.data.(*JSDocCallbackTag) + switch n.Kind { + case KindJSDocCallbackTag: + return (*JSDocCallbackTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocCallbackTag") + } } func (n *Node) AsJSDocOverloadTag() *JSDocOverloadTag { - return n.data.(*JSDocOverloadTag) + switch n.Kind { + case KindJSDocOverloadTag: + return (*JSDocOverloadTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocOverloadTag") + } } func (n *Node) AsJSDocTypedefTag() *JSDocTypedefTag { - return n.data.(*JSDocTypedefTag) + switch n.Kind { + case KindJSDocTypedefTag: + return (*JSDocTypedefTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocTypedefTag") + } } func (n *Node) AsJSDocSignature() *JSDocSignature { - return n.data.(*JSDocSignature) + switch n.Kind { + case KindJSDocSignature: + return (*JSDocSignature)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocSignature") + } } func (n *Node) AsJSDocNameReference() *JSDocNameReference { - return n.data.(*JSDocNameReference) + switch n.Kind { + case KindJSDocNameReference: + return (*JSDocNameReference)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocNameReference") + } } func (n *Node) AsSourceFile() *SourceFile { - return n.data.(*SourceFile) + switch n.Kind { + case KindSourceFile: + return (*SourceFile)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SourceFile") + } } func (n *Node) AsModuleDeclaration() *ModuleDeclaration { - return n.data.(*ModuleDeclaration) + switch n.Kind { + case KindModuleDeclaration: + return (*ModuleDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ModuleDeclaration") + } } func (n *Node) AsImportEqualsDeclaration() *ImportEqualsDeclaration { - return n.data.(*ImportEqualsDeclaration) + switch n.Kind { + case KindImportEqualsDeclaration: + return (*ImportEqualsDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ImportEqualsDeclaration") + } } func (n *Node) AsExportDeclaration() *ExportDeclaration { - return n.data.(*ExportDeclaration) + switch n.Kind { + case KindExportDeclaration: + return (*ExportDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ExportDeclaration") + } } func (n *Node) AsImportTypeNode() *ImportTypeNode { - return n.data.(*ImportTypeNode) + switch n.Kind { + case KindImportType: + return (*ImportTypeNode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ImportTypeNode") + } } func (n *Node) AsImportClause() *ImportClause { - return n.data.(*ImportClause) + switch n.Kind { + case KindImportClause: + return (*ImportClause)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ImportClause") + } } func (n *Node) AsImportSpecifier() *ImportSpecifier { - return n.data.(*ImportSpecifier) + switch n.Kind { + case KindImportSpecifier: + return (*ImportSpecifier)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to ImportSpecifier") + } } func (n *Node) AsJSDocText() *JSDocText { - return n.data.(*JSDocText) + switch n.Kind { + case KindJSDocText: + return (*JSDocText)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocText") + } } func (n *Node) AsJSDocLink() *JSDocLink { - return n.data.(*JSDocLink) + switch n.Kind { + case KindJSDocLink: + return (*JSDocLink)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocLink") + } } func (n *Node) AsJSDocLinkPlain() *JSDocLinkPlain { - return n.data.(*JSDocLinkPlain) + switch n.Kind { + case KindJSDocLinkPlain: + return (*JSDocLinkPlain)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocLinkPlain") + } } func (n *Node) AsJSDocLinkCode() *JSDocLinkCode { - return n.data.(*JSDocLinkCode) + switch n.Kind { + case KindJSDocLinkCode: + return (*JSDocLinkCode)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocLinkCode") + } } func (n *Node) AsTypeParameterDeclaration() *TypeParameterDeclaration { - return n.data.(*TypeParameterDeclaration) + switch n.Kind { + case KindTypeParameter: + return (*TypeParameterDeclaration)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to TypeParameterDeclaration") + } } func (n *Node) AsSyntheticReferenceExpression() *SyntheticReferenceExpression { - return n.data.(*SyntheticReferenceExpression) + switch n.Kind { + case KindSyntheticReferenceExpression: + return (*SyntheticReferenceExpression)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to SyntheticReferenceExpression") + } } func (n *Node) AsJSDocTypeLiteral() *JSDocTypeLiteral { - return n.data.(*JSDocTypeLiteral) + switch n.Kind { + case KindJSDocTypeLiteral: + return (*JSDocTypeLiteral)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocTypeLiteral") + } } func (n *Node) AsJSDocParameterOrPropertyTag() *JSDocParameterOrPropertyTag { - return n.data.(*JSDocParameterOrPropertyTag) + switch n.Kind { + case KindJSDocParameterTag, KindJSDocPropertyTag: + return (*JSDocParameterOrPropertyTag)(unsafe.Pointer(n)) + default: + panic("Cannot cast " + n.Kind.String() + " to JSDocParameterOrPropertyTag") + } } // ────────────────────────────────────────────────────────────────────── diff --git a/internal/ast/flow.go b/internal/ast/flow.go index 274a92f7166..57962689fe3 100644 --- a/internal/ast/flow.go +++ b/internal/ast/flow.go @@ -38,6 +38,11 @@ type FlowList struct { type FlowLabel = FlowNode +const ( + kindFlowSwitchClauseData Kind = KindCount + iota + kindFlowReduceLabelData +) + // FlowSwitchClauseData (synthetic AST node for FlowFlagsSwitchClause) type FlowSwitchClauseData struct { @@ -52,7 +57,7 @@ func NewFlowSwitchClauseData(switchStatement *Node, clauseStart int, clauseEnd i node.SwitchStatement = switchStatement node.ClauseStart = int32(clauseStart) node.ClauseEnd = int32(clauseEnd) - return newNode(KindUnknown, node, NodeFactoryHooks{}) + return newNode(kindFlowSwitchClauseData, node.AsNode(), NodeFactoryHooks{}) } func (node *FlowSwitchClauseData) IsEmpty() bool { @@ -71,5 +76,5 @@ func NewFlowReduceLabelData(target *FlowLabel, antecedents *FlowList) *Node { node := &FlowReduceLabelData{} node.Target = target node.Antecedents = antecedents - return newNode(KindUnknown, node, NodeFactoryHooks{}) + return newNode(kindFlowReduceLabelData, node.AsNode(), NodeFactoryHooks{}) } diff --git a/internal/ast/kind_stringer_generated.go b/internal/ast/kind_stringer_generated.go index b80f1ba5319..0548cb34a47 100644 --- a/internal/ast/kind_stringer_generated.go +++ b/internal/ast/kind_stringer_generated.go @@ -8,6 +8,8 @@ func _() { // An "invalid array index" compiler error signifies that the constant values have changed. // Re-run the stringer command to generate them again. var x [1]struct{} + _ = x[kindFlowSwitchClauseData-351] + _ = x[kindFlowReduceLabelData-352] _ = x[KindUnknown-0] _ = x[KindEndOfFile-1] _ = x[KindSingleLineCommentTrivia-2] @@ -362,9 +364,9 @@ func _() { _ = x[KindCount-351] } -const _Kind_name = "KindUnknownKindEndOfFileKindSingleLineCommentTriviaKindMultiLineCommentTriviaKindNewLineTriviaKindWhitespaceTriviaKindConflictMarkerTriviaKindNonTextFileMarkerTriviaKindNumericLiteralKindBigIntLiteralKindStringLiteralKindJsxTextKindJsxTextAllWhiteSpacesKindRegularExpressionLiteralKindNoSubstitutionTemplateLiteralKindTemplateHeadKindTemplateMiddleKindTemplateTailKindOpenBraceTokenKindCloseBraceTokenKindOpenParenTokenKindCloseParenTokenKindOpenBracketTokenKindCloseBracketTokenKindDotTokenKindDotDotDotTokenKindSemicolonTokenKindCommaTokenKindQuestionDotTokenKindLessThanTokenKindLessThanSlashTokenKindGreaterThanTokenKindLessThanEqualsTokenKindGreaterThanEqualsTokenKindEqualsEqualsTokenKindExclamationEqualsTokenKindEqualsEqualsEqualsTokenKindExclamationEqualsEqualsTokenKindEqualsGreaterThanTokenKindPlusTokenKindMinusTokenKindAsteriskTokenKindAsteriskAsteriskTokenKindSlashTokenKindPercentTokenKindPlusPlusTokenKindMinusMinusTokenKindLessThanLessThanTokenKindGreaterThanGreaterThanTokenKindGreaterThanGreaterThanGreaterThanTokenKindAmpersandTokenKindBarTokenKindCaretTokenKindExclamationTokenKindTildeTokenKindAmpersandAmpersandTokenKindBarBarTokenKindQuestionTokenKindColonTokenKindAtTokenKindQuestionQuestionTokenKindBacktickTokenKindHashTokenKindEqualsTokenKindPlusEqualsTokenKindMinusEqualsTokenKindAsteriskEqualsTokenKindAsteriskAsteriskEqualsTokenKindSlashEqualsTokenKindPercentEqualsTokenKindLessThanLessThanEqualsTokenKindGreaterThanGreaterThanEqualsTokenKindGreaterThanGreaterThanGreaterThanEqualsTokenKindAmpersandEqualsTokenKindBarEqualsTokenKindBarBarEqualsTokenKindAmpersandAmpersandEqualsTokenKindQuestionQuestionEqualsTokenKindCaretEqualsTokenKindIdentifierKindPrivateIdentifierKindJSDocCommentTextTokenKindBreakKeywordKindCaseKeywordKindCatchKeywordKindClassKeywordKindConstKeywordKindContinueKeywordKindDebuggerKeywordKindDefaultKeywordKindDeleteKeywordKindDoKeywordKindElseKeywordKindEnumKeywordKindExportKeywordKindExtendsKeywordKindFalseKeywordKindFinallyKeywordKindForKeywordKindFunctionKeywordKindIfKeywordKindImportKeywordKindInKeywordKindInstanceOfKeywordKindNewKeywordKindNullKeywordKindReturnKeywordKindSuperKeywordKindSwitchKeywordKindThisKeywordKindThrowKeywordKindTrueKeywordKindTryKeywordKindTypeOfKeywordKindVarKeywordKindVoidKeywordKindWhileKeywordKindWithKeywordKindImplementsKeywordKindInterfaceKeywordKindLetKeywordKindPackageKeywordKindPrivateKeywordKindProtectedKeywordKindPublicKeywordKindStaticKeywordKindYieldKeywordKindAbstractKeywordKindAccessorKeywordKindAsKeywordKindAssertsKeywordKindAssertKeywordKindAnyKeywordKindAsyncKeywordKindAwaitKeywordKindBooleanKeywordKindConstructorKeywordKindDeclareKeywordKindGetKeywordKindImmediateKeywordKindInferKeywordKindIntrinsicKeywordKindIsKeywordKindKeyOfKeywordKindModuleKeywordKindNamespaceKeywordKindNeverKeywordKindOutKeywordKindReadonlyKeywordKindRequireKeywordKindNumberKeywordKindObjectKeywordKindSatisfiesKeywordKindSetKeywordKindStringKeywordKindSymbolKeywordKindTypeKeywordKindUndefinedKeywordKindUniqueKeywordKindUnknownKeywordKindUsingKeywordKindFromKeywordKindGlobalKeywordKindBigIntKeywordKindOverrideKeywordKindOfKeywordKindDeferKeywordKindQualifiedNameKindComputedPropertyNameKindTypeParameterKindParameterKindDecoratorKindPropertySignatureKindPropertyDeclarationKindMethodSignatureKindMethodDeclarationKindClassStaticBlockDeclarationKindConstructorKindGetAccessorKindSetAccessorKindCallSignatureKindConstructSignatureKindIndexSignatureKindTypePredicateKindTypeReferenceKindFunctionTypeKindConstructorTypeKindTypeQueryKindTypeLiteralKindArrayTypeKindTupleTypeKindOptionalTypeKindRestTypeKindUnionTypeKindIntersectionTypeKindConditionalTypeKindInferTypeKindParenthesizedTypeKindThisTypeKindTypeOperatorKindIndexedAccessTypeKindMappedTypeKindLiteralTypeKindNamedTupleMemberKindTemplateLiteralTypeKindTemplateLiteralTypeSpanKindImportTypeKindObjectBindingPatternKindArrayBindingPatternKindBindingElementKindArrayLiteralExpressionKindObjectLiteralExpressionKindPropertyAccessExpressionKindElementAccessExpressionKindCallExpressionKindNewExpressionKindTaggedTemplateExpressionKindTypeAssertionExpressionKindParenthesizedExpressionKindFunctionExpressionKindArrowFunctionKindDeleteExpressionKindTypeOfExpressionKindVoidExpressionKindAwaitExpressionKindPrefixUnaryExpressionKindPostfixUnaryExpressionKindBinaryExpressionKindConditionalExpressionKindTemplateExpressionKindYieldExpressionKindSpreadElementKindClassExpressionKindOmittedExpressionKindExpressionWithTypeArgumentsKindAsExpressionKindNonNullExpressionKindMetaPropertyKindSyntheticExpressionKindSatisfiesExpressionKindTemplateSpanKindSemicolonClassElementKindBlockKindEmptyStatementKindVariableStatementKindExpressionStatementKindIfStatementKindDoStatementKindWhileStatementKindForStatementKindForInStatementKindForOfStatementKindContinueStatementKindBreakStatementKindReturnStatementKindWithStatementKindSwitchStatementKindLabeledStatementKindThrowStatementKindTryStatementKindDebuggerStatementKindVariableDeclarationKindVariableDeclarationListKindFunctionDeclarationKindClassDeclarationKindInterfaceDeclarationKindTypeAliasDeclarationKindEnumDeclarationKindModuleDeclarationKindModuleBlockKindCaseBlockKindNamespaceExportDeclarationKindImportEqualsDeclarationKindImportDeclarationKindImportClauseKindNamespaceImportKindNamedImportsKindImportSpecifierKindExportAssignmentKindExportDeclarationKindNamedExportsKindNamespaceExportKindExportSpecifierKindMissingDeclarationKindExternalModuleReferenceKindJsxElementKindJsxSelfClosingElementKindJsxOpeningElementKindJsxClosingElementKindJsxFragmentKindJsxOpeningFragmentKindJsxClosingFragmentKindJsxAttributeKindJsxAttributesKindJsxSpreadAttributeKindJsxExpressionKindJsxNamespacedNameKindCaseClauseKindDefaultClauseKindHeritageClauseKindCatchClauseKindImportAttributesKindImportAttributeKindPropertyAssignmentKindShorthandPropertyAssignmentKindSpreadAssignmentKindEnumMemberKindSourceFileKindJSDocTypeExpressionKindJSDocNameReferenceKindJSDocAllTypeKindJSDocNullableTypeKindJSDocNonNullableTypeKindJSDocOptionalTypeKindJSDocVariadicTypeKindJSDocKindJSDocTextKindJSDocTypeLiteralKindJSDocSignatureKindJSDocLinkKindJSDocLinkCodeKindJSDocLinkPlainKindJSDocUnknownTagKindJSDocAugmentsTagKindJSDocImplementsTagKindJSDocDeprecatedTagKindJSDocPublicTagKindJSDocPrivateTagKindJSDocProtectedTagKindJSDocReadonlyTagKindJSDocOverrideTagKindJSDocCallbackTagKindJSDocOverloadTagKindJSDocParameterTagKindJSDocReturnTagKindJSDocThisTagKindJSDocTypeTagKindJSDocTemplateTagKindJSDocTypedefTagKindJSDocSeeTagKindJSDocPropertyTagKindJSDocThrowsTagKindJSDocSatisfiesTagKindJSDocImportTagKindSyntaxListKindJSTypeAliasDeclarationKindJSImportDeclarationKindNotEmittedStatementKindPartiallyEmittedExpressionKindSyntheticReferenceExpressionKindNotEmittedTypeElementKindCount" +const _Kind_name = "KindUnknownKindEndOfFileKindSingleLineCommentTriviaKindMultiLineCommentTriviaKindNewLineTriviaKindWhitespaceTriviaKindConflictMarkerTriviaKindNonTextFileMarkerTriviaKindNumericLiteralKindBigIntLiteralKindStringLiteralKindJsxTextKindJsxTextAllWhiteSpacesKindRegularExpressionLiteralKindNoSubstitutionTemplateLiteralKindTemplateHeadKindTemplateMiddleKindTemplateTailKindOpenBraceTokenKindCloseBraceTokenKindOpenParenTokenKindCloseParenTokenKindOpenBracketTokenKindCloseBracketTokenKindDotTokenKindDotDotDotTokenKindSemicolonTokenKindCommaTokenKindQuestionDotTokenKindLessThanTokenKindLessThanSlashTokenKindGreaterThanTokenKindLessThanEqualsTokenKindGreaterThanEqualsTokenKindEqualsEqualsTokenKindExclamationEqualsTokenKindEqualsEqualsEqualsTokenKindExclamationEqualsEqualsTokenKindEqualsGreaterThanTokenKindPlusTokenKindMinusTokenKindAsteriskTokenKindAsteriskAsteriskTokenKindSlashTokenKindPercentTokenKindPlusPlusTokenKindMinusMinusTokenKindLessThanLessThanTokenKindGreaterThanGreaterThanTokenKindGreaterThanGreaterThanGreaterThanTokenKindAmpersandTokenKindBarTokenKindCaretTokenKindExclamationTokenKindTildeTokenKindAmpersandAmpersandTokenKindBarBarTokenKindQuestionTokenKindColonTokenKindAtTokenKindQuestionQuestionTokenKindBacktickTokenKindHashTokenKindEqualsTokenKindPlusEqualsTokenKindMinusEqualsTokenKindAsteriskEqualsTokenKindAsteriskAsteriskEqualsTokenKindSlashEqualsTokenKindPercentEqualsTokenKindLessThanLessThanEqualsTokenKindGreaterThanGreaterThanEqualsTokenKindGreaterThanGreaterThanGreaterThanEqualsTokenKindAmpersandEqualsTokenKindBarEqualsTokenKindBarBarEqualsTokenKindAmpersandAmpersandEqualsTokenKindQuestionQuestionEqualsTokenKindCaretEqualsTokenKindIdentifierKindPrivateIdentifierKindJSDocCommentTextTokenKindBreakKeywordKindCaseKeywordKindCatchKeywordKindClassKeywordKindConstKeywordKindContinueKeywordKindDebuggerKeywordKindDefaultKeywordKindDeleteKeywordKindDoKeywordKindElseKeywordKindEnumKeywordKindExportKeywordKindExtendsKeywordKindFalseKeywordKindFinallyKeywordKindForKeywordKindFunctionKeywordKindIfKeywordKindImportKeywordKindInKeywordKindInstanceOfKeywordKindNewKeywordKindNullKeywordKindReturnKeywordKindSuperKeywordKindSwitchKeywordKindThisKeywordKindThrowKeywordKindTrueKeywordKindTryKeywordKindTypeOfKeywordKindVarKeywordKindVoidKeywordKindWhileKeywordKindWithKeywordKindImplementsKeywordKindInterfaceKeywordKindLetKeywordKindPackageKeywordKindPrivateKeywordKindProtectedKeywordKindPublicKeywordKindStaticKeywordKindYieldKeywordKindAbstractKeywordKindAccessorKeywordKindAsKeywordKindAssertsKeywordKindAssertKeywordKindAnyKeywordKindAsyncKeywordKindAwaitKeywordKindBooleanKeywordKindConstructorKeywordKindDeclareKeywordKindGetKeywordKindImmediateKeywordKindInferKeywordKindIntrinsicKeywordKindIsKeywordKindKeyOfKeywordKindModuleKeywordKindNamespaceKeywordKindNeverKeywordKindOutKeywordKindReadonlyKeywordKindRequireKeywordKindNumberKeywordKindObjectKeywordKindSatisfiesKeywordKindSetKeywordKindStringKeywordKindSymbolKeywordKindTypeKeywordKindUndefinedKeywordKindUniqueKeywordKindUnknownKeywordKindUsingKeywordKindFromKeywordKindGlobalKeywordKindBigIntKeywordKindOverrideKeywordKindOfKeywordKindDeferKeywordKindQualifiedNameKindComputedPropertyNameKindTypeParameterKindParameterKindDecoratorKindPropertySignatureKindPropertyDeclarationKindMethodSignatureKindMethodDeclarationKindClassStaticBlockDeclarationKindConstructorKindGetAccessorKindSetAccessorKindCallSignatureKindConstructSignatureKindIndexSignatureKindTypePredicateKindTypeReferenceKindFunctionTypeKindConstructorTypeKindTypeQueryKindTypeLiteralKindArrayTypeKindTupleTypeKindOptionalTypeKindRestTypeKindUnionTypeKindIntersectionTypeKindConditionalTypeKindInferTypeKindParenthesizedTypeKindThisTypeKindTypeOperatorKindIndexedAccessTypeKindMappedTypeKindLiteralTypeKindNamedTupleMemberKindTemplateLiteralTypeKindTemplateLiteralTypeSpanKindImportTypeKindObjectBindingPatternKindArrayBindingPatternKindBindingElementKindArrayLiteralExpressionKindObjectLiteralExpressionKindPropertyAccessExpressionKindElementAccessExpressionKindCallExpressionKindNewExpressionKindTaggedTemplateExpressionKindTypeAssertionExpressionKindParenthesizedExpressionKindFunctionExpressionKindArrowFunctionKindDeleteExpressionKindTypeOfExpressionKindVoidExpressionKindAwaitExpressionKindPrefixUnaryExpressionKindPostfixUnaryExpressionKindBinaryExpressionKindConditionalExpressionKindTemplateExpressionKindYieldExpressionKindSpreadElementKindClassExpressionKindOmittedExpressionKindExpressionWithTypeArgumentsKindAsExpressionKindNonNullExpressionKindMetaPropertyKindSyntheticExpressionKindSatisfiesExpressionKindTemplateSpanKindSemicolonClassElementKindBlockKindEmptyStatementKindVariableStatementKindExpressionStatementKindIfStatementKindDoStatementKindWhileStatementKindForStatementKindForInStatementKindForOfStatementKindContinueStatementKindBreakStatementKindReturnStatementKindWithStatementKindSwitchStatementKindLabeledStatementKindThrowStatementKindTryStatementKindDebuggerStatementKindVariableDeclarationKindVariableDeclarationListKindFunctionDeclarationKindClassDeclarationKindInterfaceDeclarationKindTypeAliasDeclarationKindEnumDeclarationKindModuleDeclarationKindModuleBlockKindCaseBlockKindNamespaceExportDeclarationKindImportEqualsDeclarationKindImportDeclarationKindImportClauseKindNamespaceImportKindNamedImportsKindImportSpecifierKindExportAssignmentKindExportDeclarationKindNamedExportsKindNamespaceExportKindExportSpecifierKindMissingDeclarationKindExternalModuleReferenceKindJsxElementKindJsxSelfClosingElementKindJsxOpeningElementKindJsxClosingElementKindJsxFragmentKindJsxOpeningFragmentKindJsxClosingFragmentKindJsxAttributeKindJsxAttributesKindJsxSpreadAttributeKindJsxExpressionKindJsxNamespacedNameKindCaseClauseKindDefaultClauseKindHeritageClauseKindCatchClauseKindImportAttributesKindImportAttributeKindPropertyAssignmentKindShorthandPropertyAssignmentKindSpreadAssignmentKindEnumMemberKindSourceFileKindJSDocTypeExpressionKindJSDocNameReferenceKindJSDocAllTypeKindJSDocNullableTypeKindJSDocNonNullableTypeKindJSDocOptionalTypeKindJSDocVariadicTypeKindJSDocKindJSDocTextKindJSDocTypeLiteralKindJSDocSignatureKindJSDocLinkKindJSDocLinkCodeKindJSDocLinkPlainKindJSDocUnknownTagKindJSDocAugmentsTagKindJSDocImplementsTagKindJSDocDeprecatedTagKindJSDocPublicTagKindJSDocPrivateTagKindJSDocProtectedTagKindJSDocReadonlyTagKindJSDocOverrideTagKindJSDocCallbackTagKindJSDocOverloadTagKindJSDocParameterTagKindJSDocReturnTagKindJSDocThisTagKindJSDocTypeTagKindJSDocTemplateTagKindJSDocTypedefTagKindJSDocSeeTagKindJSDocPropertyTagKindJSDocThrowsTagKindJSDocSatisfiesTagKindJSDocImportTagKindSyntaxListKindJSTypeAliasDeclarationKindJSImportDeclarationKindNotEmittedStatementKindPartiallyEmittedExpressionKindSyntheticReferenceExpressionKindNotEmittedTypeElementkindFlowSwitchClauseDatakindFlowReduceLabelData" -var _Kind_index = [...]uint16{0, 11, 24, 51, 77, 94, 114, 138, 165, 183, 200, 217, 228, 253, 281, 314, 330, 348, 364, 382, 401, 419, 438, 458, 479, 491, 509, 527, 541, 561, 578, 600, 620, 643, 669, 690, 716, 743, 775, 801, 814, 828, 845, 870, 884, 900, 917, 936, 961, 992, 1034, 1052, 1064, 1078, 1098, 1112, 1139, 1154, 1171, 1185, 1196, 1221, 1238, 1251, 1266, 1285, 1305, 1328, 1359, 1379, 1401, 1432, 1469, 1517, 1541, 1559, 1580, 1613, 1644, 1664, 1678, 1699, 1724, 1740, 1755, 1771, 1787, 1803, 1822, 1841, 1859, 1876, 1889, 1904, 1919, 1936, 1954, 1970, 1988, 2002, 2021, 2034, 2051, 2064, 2085, 2099, 2114, 2131, 2147, 2164, 2179, 2195, 2210, 2224, 2241, 2255, 2270, 2286, 2301, 2322, 2342, 2356, 2374, 2392, 2412, 2429, 2446, 2462, 2481, 2500, 2513, 2531, 2548, 2562, 2578, 2594, 2612, 2634, 2652, 2666, 2686, 2702, 2722, 2735, 2751, 2768, 2788, 2804, 2818, 2837, 2855, 2872, 2889, 2909, 2923, 2940, 2957, 2972, 2992, 3009, 3027, 3043, 3058, 3075, 3092, 3111, 3124, 3140, 3157, 3181, 3198, 3211, 3224, 3245, 3268, 3287, 3308, 3339, 3354, 3369, 3384, 3401, 3423, 3441, 3458, 3475, 3491, 3510, 3523, 3538, 3551, 3564, 3580, 3592, 3605, 3625, 3644, 3657, 3678, 3690, 3706, 3727, 3741, 3756, 3776, 3799, 3826, 3840, 3864, 3887, 3905, 3931, 3958, 3986, 4013, 4031, 4048, 4076, 4103, 4130, 4152, 4169, 4189, 4209, 4227, 4246, 4271, 4297, 4317, 4342, 4364, 4383, 4400, 4419, 4440, 4471, 4487, 4508, 4524, 4547, 4570, 4586, 4611, 4620, 4638, 4659, 4682, 4697, 4712, 4730, 4746, 4764, 4782, 4803, 4821, 4840, 4857, 4876, 4896, 4914, 4930, 4951, 4974, 5001, 5024, 5044, 5068, 5092, 5111, 5132, 5147, 5160, 5190, 5217, 5238, 5254, 5273, 5289, 5308, 5328, 5349, 5365, 5384, 5403, 5425, 5452, 5466, 5491, 5512, 5533, 5548, 5570, 5592, 5608, 5625, 5647, 5664, 5685, 5699, 5716, 5734, 5749, 5769, 5788, 5810, 5841, 5861, 5875, 5889, 5912, 5934, 5950, 5971, 5995, 6016, 6037, 6046, 6059, 6079, 6097, 6110, 6127, 6145, 6164, 6184, 6206, 6228, 6246, 6265, 6286, 6306, 6326, 6346, 6366, 6387, 6405, 6421, 6437, 6457, 6476, 6491, 6511, 6529, 6550, 6568, 6582, 6608, 6631, 6654, 6684, 6716, 6741, 6750} +var _Kind_index = [...]uint16{0, 11, 24, 51, 77, 94, 114, 138, 165, 183, 200, 217, 228, 253, 281, 314, 330, 348, 364, 382, 401, 419, 438, 458, 479, 491, 509, 527, 541, 561, 578, 600, 620, 643, 669, 690, 716, 743, 775, 801, 814, 828, 845, 870, 884, 900, 917, 936, 961, 992, 1034, 1052, 1064, 1078, 1098, 1112, 1139, 1154, 1171, 1185, 1196, 1221, 1238, 1251, 1266, 1285, 1305, 1328, 1359, 1379, 1401, 1432, 1469, 1517, 1541, 1559, 1580, 1613, 1644, 1664, 1678, 1699, 1724, 1740, 1755, 1771, 1787, 1803, 1822, 1841, 1859, 1876, 1889, 1904, 1919, 1936, 1954, 1970, 1988, 2002, 2021, 2034, 2051, 2064, 2085, 2099, 2114, 2131, 2147, 2164, 2179, 2195, 2210, 2224, 2241, 2255, 2270, 2286, 2301, 2322, 2342, 2356, 2374, 2392, 2412, 2429, 2446, 2462, 2481, 2500, 2513, 2531, 2548, 2562, 2578, 2594, 2612, 2634, 2652, 2666, 2686, 2702, 2722, 2735, 2751, 2768, 2788, 2804, 2818, 2837, 2855, 2872, 2889, 2909, 2923, 2940, 2957, 2972, 2992, 3009, 3027, 3043, 3058, 3075, 3092, 3111, 3124, 3140, 3157, 3181, 3198, 3211, 3224, 3245, 3268, 3287, 3308, 3339, 3354, 3369, 3384, 3401, 3423, 3441, 3458, 3475, 3491, 3510, 3523, 3538, 3551, 3564, 3580, 3592, 3605, 3625, 3644, 3657, 3678, 3690, 3706, 3727, 3741, 3756, 3776, 3799, 3826, 3840, 3864, 3887, 3905, 3931, 3958, 3986, 4013, 4031, 4048, 4076, 4103, 4130, 4152, 4169, 4189, 4209, 4227, 4246, 4271, 4297, 4317, 4342, 4364, 4383, 4400, 4419, 4440, 4471, 4487, 4508, 4524, 4547, 4570, 4586, 4611, 4620, 4638, 4659, 4682, 4697, 4712, 4730, 4746, 4764, 4782, 4803, 4821, 4840, 4857, 4876, 4896, 4914, 4930, 4951, 4974, 5001, 5024, 5044, 5068, 5092, 5111, 5132, 5147, 5160, 5190, 5217, 5238, 5254, 5273, 5289, 5308, 5328, 5349, 5365, 5384, 5403, 5425, 5452, 5466, 5491, 5512, 5533, 5548, 5570, 5592, 5608, 5625, 5647, 5664, 5685, 5699, 5716, 5734, 5749, 5769, 5788, 5810, 5841, 5861, 5875, 5889, 5912, 5934, 5950, 5971, 5995, 6016, 6037, 6046, 6059, 6079, 6097, 6110, 6127, 6145, 6164, 6184, 6206, 6228, 6246, 6265, 6286, 6306, 6326, 6346, 6366, 6387, 6405, 6421, 6437, 6457, 6476, 6491, 6511, 6529, 6550, 6568, 6582, 6608, 6631, 6654, 6684, 6716, 6741, 6765, 6788} func (i Kind) String() string { idx := int(i) - 0 diff --git a/internal/ast/utilities.go b/internal/ast/utilities.go index a3718cfa094..1dcd9d36d00 100644 --- a/internal/ast/utilities.go +++ b/internal/ast/utilities.go @@ -1177,32 +1177,36 @@ func GetRootDeclaration(node *Node) *Node { return node } -func getCombinedFlags[T ~uint32](node *Node, getFlags func(*Node) T) T { +func GetCombinedModifierFlags(node *Node) ModifierFlags { node = GetRootDeclaration(node) - flags := getFlags(node) + flags := node.ModifierFlags() if node.Kind == KindVariableDeclaration { node = node.Parent } if node != nil && node.Kind == KindVariableDeclarationList { - flags |= getFlags(node) + flags |= node.ModifierFlags() node = node.Parent } if node != nil && node.Kind == KindVariableStatement { - flags |= getFlags(node) + flags |= node.ModifierFlags() } return flags } -func GetCombinedModifierFlags(node *Node) ModifierFlags { - return getCombinedFlags(node, (*Node).ModifierFlags) -} - func GetCombinedNodeFlags(node *Node) NodeFlags { - return getCombinedFlags(node, getNodeFlags) -} - -func getNodeFlags(node *Node) NodeFlags { - return node.Flags + node = GetRootDeclaration(node) + flags := node.Flags + if node.Kind == KindVariableDeclaration { + node = node.Parent + } + if node != nil && node.Kind == KindVariableDeclarationList { + flags |= node.Flags + node = node.Parent + } + if node != nil && node.Kind == KindVariableStatement { + flags |= node.Flags + } + return flags } // Gets whether a bound `VariableDeclaration` or `VariableDeclarationList` is part of an `await using` declaration.