@scriptc/compiler 0.2.4 → 0.2.6

package/dist/frontend/ts7/ast-node.js

@@ -1,7 +1,7 @@
 import { AstDecodeError } from "./ast-bytes.js";
-import { AstKind, AstModifierFlags, AstNodeFlags, KIND_NODE_LIST, astChildOrder } from "./ast-schema.generated.js";
+import { AstKind, AstModifierFlags, AstNodeFlags, KIND_NODE_LIST, astChildOrder, } from "./ast-schema.generated.js";
 import { astLineOfPosition, astLineStarts, astSkipTrivia } from "./ast-text.js";
-import { AstWireFile, parseAstNodeHandle } from "./ast-wire.js";
+import { AstWireFile, parseAstNodeHandle, } from "./ast-wire.js";
 import { SyntaxKind, NodeFlags } from "./enums.js";
 /** One immutable AST response owns one object per node and one array per
  * list. Parent access is lazy, so resolving a checker handle near the bottom
@@ -11,8 +11,8 @@ export class AstFile {
     materialized;
     wire;
     root;
-    // Wire ids are bounded dense indices. Direct slots preserve lazy object
-    // creation and avoid hashing and temporary optional boxes on every read.
+    // Wire ids are bounded dense indices. Holes mark unresolved slots; present
+    // entries hold concrete nodes/lists without an optional payload wrapper.
     nodes;
     lists;
     references = new Map();
@@ -38,9 +38,8 @@ export class AstFile {
         return this.root;
     }
     node(index) {
-        const existing = this.nodes[index];
-        if (existing !== undefined)
-            return existing;
+        if (Object.hasOwn(this.nodes, index))
+            return this.nodes[index];
         if (index === 0 || this.wire.kind(index) === KIND_NODE_LIST)
             throw new AstDecodeError("expected a node index");
         const node = new AstNode(this, index);
@@ -49,9 +48,8 @@ export class AstFile {
         return node;
     }
     list(index) {
-        const existing = this.lists[index];
-        if (existing !== undefined)
-            return existing;
+        if (Object.hasOwn(this.lists, index))
+            return this.lists[index];
         const nodes = [];
         for (const child of this.wire.list(index))
             nodes.push(this.node(child));
@@ -66,7 +64,7 @@ export class AstFile {
         const order = astChildOrder(node.kind, name);
         if (order < 0)
             return 0;
-        const mask = (node.data >>> 30) === 0 ? node.data & 0xff : 0xff;
+        const mask = node.data >>> 30 === 0 ? node.data & 0xff : 0xff;
         if ((mask & (1 << order)) === 0)
             return 0;
         const slot = node.index * 8 + order;
@@ -76,7 +74,7 @@ export class AstFile {
             if (cached !== 0)
                 return cached;
         }
-        const index = this.wire.namedChild(node.index, name);
+        const index = this.wire.childAtOrder(node.index, order);
         // The pinned wire has at most eight named children per node. One packed
         // table avoids per-node arrays; allocate it only after successful access
         // so malformed siblings still fail lazily in the checked wire decoder.
@@ -86,7 +84,9 @@ export class AstFile {
         return index;
     }
     resolve(handle) {
-        const parsed = parseAstNodeHandle(handle);
+        return this.resolveHandle(parseAstNodeHandle(handle));
+    }
+    resolveHandle(parsed) {
         if (parsed.path !== this.root.path)
             throw new AstDecodeError("node handle belongs to another source file");
         const node = this.node(parsed.index);
@@ -151,7 +151,9 @@ export class AstNode {
         this.flags = wire.flags(index);
         this.data = wire.data(index);
     }
-    get id() { return `${this.index}.${this.kind}.${this.file.root.path}`; }
+    get id() {
+        return `${this.index}.${this.kind}.${this.file.root.path}`;
+    }
     get parent() {
         if (!this.parentResolved) {
             const index = this.file.wire.semanticParent(this.index);
@@ -160,8 +162,12 @@ export class AstNode {
         }
         return this.parentCache;
     }
-    get text() { return this.file.wire.text(this.index); }
-    get rawText() { return this.file.wire.rawText(this.index); }
+    get text() {
+        return this.file.wire.text(this.index);
+    }
+    get rawText() {
+        return this.file.wire.rawText(this.index);
+    }
     childNode(name) {
         const index = this.file.namedChild(this, name);
         return index === 0 ? undefined : this.file.node(index);
@@ -174,7 +180,28 @@ export class AstNode {
         const index = this.file.namedChild(this, name);
         if (index === 0)
             return undefined;
-        return this.file.wire.kind(index) === KIND_NODE_LIST ? this.file.list(index) : this.file.node(index);
+        return this.file.wire.kind(index) === KIND_NODE_LIST
+            ? this.file.list(index)
+            : this.file.node(index);
+    }
+    /** Append semantic child handles without giving a traversal worklist an
+     * owning reference to every pending node. Lists still pass through the
+     * checked, identity-preserving cache used by forEachChild. */
+    appendChildIndices(indices) {
+        const file = this.file;
+        const wire = file.wire;
+        for (let index = wire.firstChild(this.index); index !== 0; index = wire.next(index)) {
+            if (wire.parent(index) !== this.index)
+                throw new AstDecodeError("sibling belongs to another parent");
+            const kind = wire.kind(index);
+            if (kind === KIND_NODE_LIST) {
+                for (const node of file.list(index))
+                    indices.push(node.index);
+            }
+            else if (kind !== AstKind.JSDoc) {
+                indices.push(index);
+            }
+        }
     }
     forEachChild(visitNode, visitList) {
         const wire = this.file.wire;
@@ -215,13 +242,16 @@ export class AstNode {
         }
         return docs.length === 0 ? undefined : docs;
     }
-    getSourceFile() { return this.file.sourceFile; }
+    getSourceFile() {
+        return this.file.sourceFile;
+    }
     getStart(sourceFile, includeJsDocComment) {
         if (this.pos === this.end && this.pos >= 0 && this.kind !== AstKind.EndOfFile)
             return this.pos;
         const source = sourceFile ?? this.file.root;
         const text = source.text ?? "";
-        if ((this.kind >= AstKind.FirstJSDocNode && this.kind <= AstKind.LastJSDocNode) || this.kind === AstKind.JsxText) {
+        if ((this.kind >= AstKind.FirstJSDocNode && this.kind <= AstKind.LastJSDocNode) ||
+            this.kind === AstKind.JsxText) {
             return astSkipTrivia(text, this.pos, true, false);
         }
         if (includeJsDocComment) {
@@ -231,46 +261,92 @@ export class AstNode {
         }
         return astSkipTrivia(text, this.pos, false, (this.flags & AstNodeFlags.JSDoc) !== 0);
     }
-    getFullStart() { return this.pos; }
-    getEnd() { return this.end; }
-    getWidth(sourceFile) { return this.end - this.getStart(sourceFile); }
-    getFullWidth() { return this.end - this.pos; }
-    getLeadingTriviaWidth(sourceFile) { return this.getStart(sourceFile) - this.pos; }
-    getFullText(sourceFile) { return ((sourceFile ?? this.file.root).text ?? "").substring(this.pos, this.end); }
+    getFullStart() {
+        return this.pos;
+    }
+    getEnd() {
+        return this.end;
+    }
+    getWidth(sourceFile) {
+        return this.end - this.getStart(sourceFile);
+    }
+    getFullWidth() {
+        return this.end - this.pos;
+    }
+    getLeadingTriviaWidth(sourceFile) {
+        return this.getStart(sourceFile) - this.pos;
+    }
+    getFullText(sourceFile) {
+        return ((sourceFile ?? this.file.root).text ?? "").substring(this.pos, this.end);
+    }
     getText(sourceFile) {
         const source = sourceFile ?? this.file.root;
         return (source.text ?? "").substring(this.getStart(source), this.end);
     }
-    get containsOnlyTriviaWhiteSpaces() { return (this.data & (1 << 24)) !== 0; }
-    get isArrayType() { return (this.data & (1 << 24)) !== 0; }
-    get isBracketed() { return (this.data & (1 << 24)) !== 0; }
-    get isExportEquals() { return (this.data & (1 << 24)) !== 0; }
-    get isNameFirst() { return (this.data & (1 << 25)) !== 0; }
-    get isTypeOf() { return (this.data & (1 << 24)) !== 0; }
-    get isTypeOnly() { return (this.data & (1 << 24)) !== 0; }
-    get multiLine() { return (this.data & (1 << 24)) !== 0; }
+    get containsOnlyTriviaWhiteSpaces() {
+        return (this.data & (1 << 24)) !== 0;
+    }
+    get isArrayType() {
+        return (this.data & (1 << 24)) !== 0;
+    }
+    get isBracketed() {
+        return (this.data & (1 << 24)) !== 0;
+    }
+    get isExportEquals() {
+        return (this.data & (1 << 24)) !== 0;
+    }
+    get isNameFirst() {
+        return (this.data & (1 << 25)) !== 0;
+    }
+    get isTypeOf() {
+        return (this.data & (1 << 24)) !== 0;
+    }
+    get isTypeOnly() {
+        return (this.data & (1 << 24)) !== 0;
+    }
+    get multiLine() {
+        return (this.data & (1 << 24)) !== 0;
+    }
     get keyword() {
-        return this.kind === AstKind.ModuleDeclaration ? ((this.data >>> 24) & 1 ? AstKind.NamespaceKeyword : AstKind.ModuleKeyword) : undefined;
+        return this.kind === AstKind.ModuleDeclaration
+            ? (this.data >>> 24) & 1
+                ? AstKind.NamespaceKeyword
+                : AstKind.ModuleKeyword
+            : undefined;
     }
     get keywordToken() {
-        return this.kind === AstKind.MetaProperty ? ((this.data >>> 24) & 1 ? AstKind.NewKeyword : AstKind.ImportKeyword) : undefined;
+        return this.kind === AstKind.MetaProperty
+            ? (this.data >>> 24) & 1
+                ? AstKind.NewKeyword
+                : AstKind.ImportKeyword
+            : undefined;
     }
     get operator() {
         const value = (this.data >>> 24) & 7;
         if (this.kind === AstKind.PrefixUnaryExpression) {
             switch (value) {
-                case 1: return AstKind.MinusToken;
-                case 2: return AstKind.TildeToken;
-                case 3: return AstKind.ExclamationToken;
-                case 4: return AstKind.PlusPlusToken;
-                case 5: return AstKind.MinusMinusToken;
-                default: return AstKind.PlusToken;
+                case 1:
+                    return AstKind.MinusToken;
+                case 2:
+                    return AstKind.TildeToken;
+                case 3:
+                    return AstKind.ExclamationToken;
+                case 4:
+                    return AstKind.PlusPlusToken;
+                case 5:
+                    return AstKind.MinusMinusToken;
+                default:
+                    return AstKind.PlusToken;
             }
         }
         if (this.kind === AstKind.PostfixUnaryExpression)
             return value & 1 ? AstKind.MinusMinusToken : AstKind.PlusPlusToken;
         if (this.kind === AstKind.TypeOperator)
-            return (value & 3) === 1 ? AstKind.ReadonlyKeyword : (value & 3) === 2 ? AstKind.UniqueKeyword : AstKind.KeyOfKeyword;
+            return (value & 3) === 1
+                ? AstKind.ReadonlyKeyword
+                : (value & 3) === 2
+                    ? AstKind.UniqueKeyword
+                    : AstKind.KeyOfKeyword;
         return undefined;
     }
     get phaseModifier() {
@@ -287,12 +363,19 @@ export class AstNode {
         return undefined;
     }
     get templateFlags() {
-        return this.kind === AstKind.TemplateHead || this.kind === AstKind.TemplateMiddle || this.kind === AstKind.TemplateTail
-            ? this.file.wire.extendedWord(this.index, 8) : undefined;
+        return this.kind === AstKind.TemplateHead ||
+            this.kind === AstKind.TemplateMiddle ||
+            this.kind === AstKind.TemplateTail
+            ? this.file.wire.extendedWord(this.index, 8)
+            : undefined;
     }
     get tokenFlags() {
-        return this.kind === AstKind.StringLiteral || this.kind === AstKind.NumericLiteral || this.kind === AstKind.BigIntLiteral || this.kind === AstKind.RegularExpressionLiteral
-            ? this.file.wire.extendedWord(this.index, 4) : 0;
+        return this.kind === AstKind.StringLiteral ||
+            this.kind === AstKind.NumericLiteral ||
+            this.kind === AstKind.BigIntLiteral ||
+            this.kind === AstKind.RegularExpressionLiteral
+            ? this.file.wire.extendedWord(this.index, 4)
+            : 0;
     }
     get modifierFlags() {
         let result = 0;
@@ -305,9 +388,13 @@ export class AstNode {
         // TS7 can serialize a reparsed @type callable before a method's
         // body without setting the type presence bit. The linked Block is
         // still the real body; keep the JSDoc node out of this view.
-        if (body !== undefined && (body.flags & AstNodeFlags.JSDoc) !== 0 && (body.flags & AstNodeFlags.Reparsed) !== 0) {
+        if (body !== undefined &&
+            (body.flags & AstNodeFlags.JSDoc) !== 0 &&
+            (body.flags & AstNodeFlags.Reparsed) !== 0) {
             const next = this.file.wire.next(body.index);
-            if (next !== 0 && this.file.wire.parent(next) === this.index && this.file.wire.kind(next) === AstKind.Block) {
+            if (next !== 0 &&
+                this.file.wire.parent(next) === this.index &&
+                this.file.wire.kind(next) === AstKind.Block) {
                 return this.file.node(next);
             }
         }
@@ -324,119 +411,331 @@ export class AstNode {
     }
     // BEGIN GENERATED CHILD GETTERS
     // Generated from typescript@7.0.2; run scripts/generate-ts7-ast-schema.mjs.
-    get argument() { return this.childNode("argument"); }
-    get argumentExpression() { return this.childNode("argumentExpression"); }
-    get arguments() { return this.childList("arguments"); }
-    get assertsModifier() { return this.childNode("assertsModifier"); }
-    get asteriskToken() { return this.childNode("asteriskToken"); }
-    get attributes() { return this.child("attributes"); }
-    get awaitModifier() { return this.childNode("awaitModifier"); }
-    get block() { return this.childNode("block"); }
-    get caseBlock() { return this.childNode("caseBlock"); }
-    get catchClause() { return this.childNode("catchClause"); }
-    get checkType() { return this.childNode("checkType"); }
-    get children() { return this.child("children"); }
-    get className() { return this.childNode("className"); }
-    get clauses() { return this.childList("clauses"); }
-    get closingElement() { return this.childNode("closingElement"); }
-    get closingFragment() { return this.childNode("closingFragment"); }
-    get colonToken() { return this.childNode("colonToken"); }
-    get comment() { return this.childList("comment"); }
-    get condition() { return this.childNode("condition"); }
-    get constraint() { return this.childNode("constraint"); }
-    get declarationList() { return this.childNode("declarationList"); }
-    get declarations() { return this.childList("declarations"); }
-    get defaultType() { return this.childNode("defaultType"); }
-    get dotDotDotToken() { return this.childNode("dotDotDotToken"); }
-    get elementType() { return this.childNode("elementType"); }
-    get elements() { return this.childList("elements"); }
-    get elseStatement() { return this.childNode("elseStatement"); }
-    get endOfFileToken() { return this.childNode("endOfFileToken"); }
-    get equalsGreaterThanToken() { return this.childNode("equalsGreaterThanToken"); }
-    get equalsToken() { return this.childNode("equalsToken"); }
-    get exclamationToken() { return this.childNode("exclamationToken"); }
-    get exportClause() { return this.childNode("exportClause"); }
-    get exprName() { return this.childNode("exprName"); }
-    get expression() { return this.childNode("expression"); }
-    get extendsType() { return this.childNode("extendsType"); }
-    get falseType() { return this.childNode("falseType"); }
-    get finallyBlock() { return this.childNode("finallyBlock"); }
-    get head() { return this.childNode("head"); }
-    get heritageClauses() { return this.childList("heritageClauses"); }
-    get importClause() { return this.childNode("importClause"); }
-    get incrementor() { return this.childNode("incrementor"); }
-    get indexType() { return this.childNode("indexType"); }
-    get initializer() { return this.childNode("initializer"); }
-    get jsdocPropertyTags() { return this.childNode("jsdocPropertyTags"); }
-    get label() { return this.childNode("label"); }
-    get left() { return this.childNode("left"); }
-    get literal() { return this.childNode("literal"); }
-    get members() { return this.childList("members"); }
-    get modifiers() { return this.childList("modifiers"); }
-    get moduleReference() { return this.childNode("moduleReference"); }
-    get moduleSpecifier() { return this.childNode("moduleSpecifier"); }
-    get name() { return this.childNode("name"); }
-    get nameExpression() { return this.childNode("nameExpression"); }
-    get nameType() { return this.childNode("nameType"); }
-    get namedBindings() { return this.childNode("namedBindings"); }
-    get namespace() { return this.childNode("namespace"); }
-    get objectAssignmentInitializer() { return this.childNode("objectAssignmentInitializer"); }
-    get objectType() { return this.childNode("objectType"); }
-    get openingElement() { return this.childNode("openingElement"); }
-    get openingFragment() { return this.childNode("openingFragment"); }
-    get operand() { return this.childNode("operand"); }
-    get operatorToken() { return this.childNode("operatorToken"); }
-    get parameterName() { return this.childNode("parameterName"); }
-    get parameters() { return this.childList("parameters"); }
-    get postfixToken() { return this.childNode("postfixToken"); }
-    get properties() { return this.childList("properties"); }
-    get propertyName() { return this.childNode("propertyName"); }
-    get qualifier() { return this.childNode("qualifier"); }
-    get questionDotToken() { return this.childNode("questionDotToken"); }
-    get readonlyToken() { return this.childNode("readonlyToken"); }
-    get right() { return this.childNode("right"); }
-    get statement() { return this.childNode("statement"); }
-    get statements() { return this.childList("statements"); }
-    get tag() { return this.childNode("tag"); }
-    get tagName() { return this.childNode("tagName"); }
-    get tags() { return this.childList("tags"); }
-    get template() { return this.childNode("template"); }
-    get templateSpans() { return this.childList("templateSpans"); }
-    get thenStatement() { return this.childNode("thenStatement"); }
-    get thisArg() { return this.childNode("thisArg"); }
-    get trueType() { return this.childNode("trueType"); }
-    get tryBlock() { return this.childNode("tryBlock"); }
-    get tupleNameSource() { return this.childNode("tupleNameSource"); }
-    get type() { return this.childNode("type"); }
-    get typeArguments() { return this.childList("typeArguments"); }
-    get typeExpression() { return this.childNode("typeExpression"); }
-    get typeName() { return this.childNode("typeName"); }
-    get typeParameter() { return this.childNode("typeParameter"); }
-    get typeParameters() { return this.childList("typeParameters"); }
-    get types() { return this.childList("types"); }
-    get value() { return this.childNode("value"); }
-    get variableDeclaration() { return this.childNode("variableDeclaration"); }
-    get whenFalse() { return this.childNode("whenFalse"); }
-    get whenTrue() { return this.childNode("whenTrue"); }
+    get argument() {
+        return this.childNode("argument");
+    }
+    get argumentExpression() {
+        return this.childNode("argumentExpression");
+    }
+    get arguments() {
+        return this.childList("arguments");
+    }
+    get assertsModifier() {
+        return this.childNode("assertsModifier");
+    }
+    get asteriskToken() {
+        return this.childNode("asteriskToken");
+    }
+    get attributes() {
+        return this.child("attributes");
+    }
+    get awaitModifier() {
+        return this.childNode("awaitModifier");
+    }
+    get block() {
+        return this.childNode("block");
+    }
+    get caseBlock() {
+        return this.childNode("caseBlock");
+    }
+    get catchClause() {
+        return this.childNode("catchClause");
+    }
+    get checkType() {
+        return this.childNode("checkType");
+    }
+    get children() {
+        return this.child("children");
+    }
+    get className() {
+        return this.childNode("className");
+    }
+    get clauses() {
+        return this.childList("clauses");
+    }
+    get closingElement() {
+        return this.childNode("closingElement");
+    }
+    get closingFragment() {
+        return this.childNode("closingFragment");
+    }
+    get colonToken() {
+        return this.childNode("colonToken");
+    }
+    get comment() {
+        return this.childList("comment");
+    }
+    get condition() {
+        return this.childNode("condition");
+    }
+    get constraint() {
+        return this.childNode("constraint");
+    }
+    get declarationList() {
+        return this.childNode("declarationList");
+    }
+    get declarations() {
+        return this.childList("declarations");
+    }
+    get defaultType() {
+        return this.childNode("defaultType");
+    }
+    get dotDotDotToken() {
+        return this.childNode("dotDotDotToken");
+    }
+    get elementType() {
+        return this.childNode("elementType");
+    }
+    get elements() {
+        return this.childList("elements");
+    }
+    get elseStatement() {
+        return this.childNode("elseStatement");
+    }
+    get endOfFileToken() {
+        return this.childNode("endOfFileToken");
+    }
+    get equalsGreaterThanToken() {
+        return this.childNode("equalsGreaterThanToken");
+    }
+    get equalsToken() {
+        return this.childNode("equalsToken");
+    }
+    get exclamationToken() {
+        return this.childNode("exclamationToken");
+    }
+    get exportClause() {
+        return this.childNode("exportClause");
+    }
+    get exprName() {
+        return this.childNode("exprName");
+    }
+    get expression() {
+        return this.childNode("expression");
+    }
+    get extendsType() {
+        return this.childNode("extendsType");
+    }
+    get falseType() {
+        return this.childNode("falseType");
+    }
+    get finallyBlock() {
+        return this.childNode("finallyBlock");
+    }
+    get head() {
+        return this.childNode("head");
+    }
+    get heritageClauses() {
+        return this.childList("heritageClauses");
+    }
+    get importClause() {
+        return this.childNode("importClause");
+    }
+    get incrementor() {
+        return this.childNode("incrementor");
+    }
+    get indexType() {
+        return this.childNode("indexType");
+    }
+    get initializer() {
+        return this.childNode("initializer");
+    }
+    get jsdocPropertyTags() {
+        return this.childNode("jsdocPropertyTags");
+    }
+    get label() {
+        return this.childNode("label");
+    }
+    get left() {
+        return this.childNode("left");
+    }
+    get literal() {
+        return this.childNode("literal");
+    }
+    get members() {
+        return this.childList("members");
+    }
+    get modifiers() {
+        return this.childList("modifiers");
+    }
+    get moduleReference() {
+        return this.childNode("moduleReference");
+    }
+    get moduleSpecifier() {
+        return this.childNode("moduleSpecifier");
+    }
+    get name() {
+        return this.childNode("name");
+    }
+    get nameExpression() {
+        return this.childNode("nameExpression");
+    }
+    get nameType() {
+        return this.childNode("nameType");
+    }
+    get namedBindings() {
+        return this.childNode("namedBindings");
+    }
+    get namespace() {
+        return this.childNode("namespace");
+    }
+    get objectAssignmentInitializer() {
+        return this.childNode("objectAssignmentInitializer");
+    }
+    get objectType() {
+        return this.childNode("objectType");
+    }
+    get openingElement() {
+        return this.childNode("openingElement");
+    }
+    get openingFragment() {
+        return this.childNode("openingFragment");
+    }
+    get operand() {
+        return this.childNode("operand");
+    }
+    get operatorToken() {
+        return this.childNode("operatorToken");
+    }
+    get parameterName() {
+        return this.childNode("parameterName");
+    }
+    get parameters() {
+        return this.childList("parameters");
+    }
+    get postfixToken() {
+        return this.childNode("postfixToken");
+    }
+    get properties() {
+        return this.childList("properties");
+    }
+    get propertyName() {
+        return this.childNode("propertyName");
+    }
+    get qualifier() {
+        return this.childNode("qualifier");
+    }
+    get questionDotToken() {
+        return this.childNode("questionDotToken");
+    }
+    get readonlyToken() {
+        return this.childNode("readonlyToken");
+    }
+    get right() {
+        return this.childNode("right");
+    }
+    get statement() {
+        return this.childNode("statement");
+    }
+    get statements() {
+        return this.childList("statements");
+    }
+    get tag() {
+        return this.childNode("tag");
+    }
+    get tagName() {
+        return this.childNode("tagName");
+    }
+    get tags() {
+        return this.childList("tags");
+    }
+    get template() {
+        return this.childNode("template");
+    }
+    get templateSpans() {
+        return this.childList("templateSpans");
+    }
+    get thenStatement() {
+        return this.childNode("thenStatement");
+    }
+    get thisArg() {
+        return this.childNode("thisArg");
+    }
+    get trueType() {
+        return this.childNode("trueType");
+    }
+    get tryBlock() {
+        return this.childNode("tryBlock");
+    }
+    get tupleNameSource() {
+        return this.childNode("tupleNameSource");
+    }
+    get type() {
+        return this.childNode("type");
+    }
+    get typeArguments() {
+        return this.childList("typeArguments");
+    }
+    get typeExpression() {
+        return this.childNode("typeExpression");
+    }
+    get typeName() {
+        return this.childNode("typeName");
+    }
+    get typeParameter() {
+        return this.childNode("typeParameter");
+    }
+    get typeParameters() {
+        return this.childList("typeParameters");
+    }
+    get types() {
+        return this.childList("types");
+    }
+    get value() {
+        return this.childNode("value");
+    }
+    get variableDeclaration() {
+        return this.childNode("variableDeclaration");
+    }
+    get whenFalse() {
+        return this.childNode("whenFalse");
+    }
+    get whenTrue() {
+        return this.childNode("whenTrue");
+    }
     // END GENERATED CHILD GETTERS
     // Source-file fields stay on the same nominal class, matching the wire's
     // single node representation. Their extended-data accesses are checked.
-    get fileName() { return this.file.wire.string(this.file.wire.extendedWord(this.index, 4)); }
-    get path() { return this.file.wire.string(this.file.wire.extendedWord(this.index, 8)); }
-    get languageVariant() { return this.file.wire.extendedWord(this.index, 12); }
-    get scriptKind() { return this.file.wire.extendedWord(this.index, 16); }
-    get isDeclarationFile() { return (this.flags & AstNodeFlags.Ambient) !== 0; }
-    get referencedFiles() { return this.file.fileReferences(this.file.wire.extendedWord(this.index, 20)); }
-    get typeReferenceDirectives() { return this.file.fileReferences(this.file.wire.extendedWord(this.index, 24)); }
-    get libReferenceDirectives() { return this.file.fileReferences(this.file.wire.extendedWord(this.index, 28)); }
-    get imports() { return this.file.nodeReferences(this.file.wire.extendedWord(this.index, 32)); }
-    get moduleAugmentations() { return this.file.nodeReferences(this.file.wire.extendedWord(this.index, 36)); }
-    get ambientModuleNames() { return this.file.stringReferences(this.file.wire.extendedWord(this.index, 40)); }
+    get fileName() {
+        return this.file.wire.string(this.file.wire.extendedWord(this.index, 4));
+    }
+    get path() {
+        return this.file.wire.string(this.file.wire.extendedWord(this.index, 8));
+    }
+    get languageVariant() {
+        return this.file.wire.extendedWord(this.index, 12);
+    }
+    get scriptKind() {
+        return this.file.wire.extendedWord(this.index, 16);
+    }
+    get isDeclarationFile() {
+        return (this.flags & AstNodeFlags.Ambient) !== 0;
+    }
+    get referencedFiles() {
+        return this.file.fileReferences(this.file.wire.extendedWord(this.index, 20));
+    }
+    get typeReferenceDirectives() {
+        return this.file.fileReferences(this.file.wire.extendedWord(this.index, 24));
+    }
+    get libReferenceDirectives() {
+        return this.file.fileReferences(this.file.wire.extendedWord(this.index, 28));
+    }
+    get imports() {
+        return this.file.nodeReferences(this.file.wire.extendedWord(this.index, 32));
+    }
+    get moduleAugmentations() {
+        return this.file.nodeReferences(this.file.wire.extendedWord(this.index, 36));
+    }
+    get ambientModuleNames() {
+        return this.file.stringReferences(this.file.wire.extendedWord(this.index, 40));
+    }
     get externalModuleIndicator() {
         const index = this.file.wire.extendedWord(this.index, 44);
         return index === 0 ? undefined : index === this.index ? true : this.file.node(index);
     }
-    getLineStarts() { return this.file.lineStarts(); }
+    getLineStarts() {
+        return this.file.lineStarts();
+    }
     getLineAndCharacterOfPosition(position) {
         const starts = this.getLineStarts();
         const line = astLineOfPosition(starts, position);
@@ -448,27 +747,46 @@ export class AstNode {
             throw new Error(`Bad line number. Line: ${line}, lineStarts.length: ${starts.length}`);
         return starts[line] + character;
     }
-    getOrCreateNodeAtIndex(index) { return this.file.node(index); }
+    getOrCreateNodeAtIndex(index) {
+        return this.file.node(index);
+    }
 }
 function astModifierFlag(kind) {
     switch (kind) {
-        case AstKind.StaticKeyword: return AstModifierFlags.Static;
-        case AstKind.PublicKeyword: return AstModifierFlags.Public;
-        case AstKind.ProtectedKeyword: return AstModifierFlags.Protected;
-        case AstKind.PrivateKeyword: return AstModifierFlags.Private;
-        case AstKind.AbstractKeyword: return AstModifierFlags.Abstract;
-        case AstKind.AccessorKeyword: return AstModifierFlags.Accessor;
-        case AstKind.ExportKeyword: return AstModifierFlags.Export;
-        case AstKind.DeclareKeyword: return AstModifierFlags.Ambient;
-        case AstKind.ConstKeyword: return AstModifierFlags.Const;
-        case AstKind.DefaultKeyword: return AstModifierFlags.Default;
-        case AstKind.AsyncKeyword: return AstModifierFlags.Async;
-        case AstKind.ReadonlyKeyword: return AstModifierFlags.Readonly;
-        case AstKind.OverrideKeyword: return AstModifierFlags.Override;
-        case AstKind.InKeyword: return AstModifierFlags.In;
-        case AstKind.OutKeyword: return AstModifierFlags.Out;
-        case AstKind.Decorator: return AstModifierFlags.Decorator;
-        default: return AstModifierFlags.None;
+        case AstKind.StaticKeyword:
+            return AstModifierFlags.Static;
+        case AstKind.PublicKeyword:
+            return AstModifierFlags.Public;
+        case AstKind.ProtectedKeyword:
+            return AstModifierFlags.Protected;
+        case AstKind.PrivateKeyword:
+            return AstModifierFlags.Private;
+        case AstKind.AbstractKeyword:
+            return AstModifierFlags.Abstract;
+        case AstKind.AccessorKeyword:
+            return AstModifierFlags.Accessor;
+        case AstKind.ExportKeyword:
+            return AstModifierFlags.Export;
+        case AstKind.DeclareKeyword:
+            return AstModifierFlags.Ambient;
+        case AstKind.ConstKeyword:
+            return AstModifierFlags.Const;
+        case AstKind.DefaultKeyword:
+            return AstModifierFlags.Default;
+        case AstKind.AsyncKeyword:
+            return AstModifierFlags.Async;
+        case AstKind.ReadonlyKeyword:
+            return AstModifierFlags.Readonly;
+        case AstKind.OverrideKeyword:
+            return AstModifierFlags.Override;
+        case AstKind.InKeyword:
+            return AstModifierFlags.In;
+        case AstKind.OutKeyword:
+            return AstModifierFlags.Out;
+        case AstKind.Decorator:
+            return AstModifierFlags.Decorator;
+        default:
+            return AstModifierFlags.None;
     }
 }
 //# sourceMappingURL=ast-node.js.map