@scriptc/compiler 0.4.1 → 0.4.3

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

@@ -1,8 +1,16 @@
 import { AstDecodeError } from "./ast-bytes.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, PREORDER_LIST, parseAstNodeHandle, } from "./ast-wire.js";
 import { SyntaxKind, NodeFlags } from "./enums.js";
+/** Receives the file name of a source file whose raw text or line
+ * positions a reader takes: the text of a node other than a token
+ * (getText), a node's text with its trivia (getFullText), or line starts. */
+let sourceTextObserver;
+/** Installs the observer of raw source text reads (sourceTextObserver). */
+export function observeSourceText(observer) {
+    sourceTextObserver = observer;
+}
 /** A list of child nodes with the list's own position, the shape of tsc-ts's
  * NodeList. The file keeps the nodes array, not this object: each read of a
  * list field returns a new AstNodeList over the same array, so `nodes` keeps
@@ -43,10 +51,6 @@ export class AstModifierList extends AstNodeList {
         return result;
     }
 }
-/** 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
- * of a deep tree never recursively constructs its ancestors. */
 export class AstFile {
     materialized;
     wire;
@@ -60,8 +64,14 @@ export class AstFile {
     strings = new Map();
     lines;
     childIndices;
-    constructor(bytes, materialized) {
+    /** The root source file's name (AstNode.fileName). */
+    rootFileName;
+    /** Whether nodes answer write targets without their wrappers (see
+     * AstFileOptions.writeTargets). */
+    writeTargets;
+    constructor(bytes, materialized, options = {}) {
         this.materialized = materialized;
+        this.writeTargets = options.writeTargets === true;
         this.wire = new AstWireFile(bytes);
         this.nodes = new Array(this.wire.nodeCount);
         this.lists = new Array(this.wire.nodeCount);
@@ -77,8 +87,9 @@ export class AstFile {
         return this.root;
     }
     node(index) {
-        if (Object.hasOwn(this.nodes, index))
-            return this.nodes[index];
+        const existing = this.nodes[index];
+        if (existing !== undefined)
+            return existing;
         if (index === 0 || this.wire.kind(index) === KIND_NODE_LIST)
             throw new AstDecodeError("expected a node index");
         const node = new AstNode(this, index);
@@ -104,9 +115,13 @@ export class AstFile {
         return nodes;
     }
     namedChild(node, name) {
+        return this.namedChildAt(node, astChildOrder(node.kind, name));
+    }
+    /** The child in wire slot `order` (astChildOrder), or 0 when the slot is
+     * negative or empty. */
+    namedChildAt(node, order) {
         if (node.file !== this)
             throw new AstDecodeError("named child belongs to another source file");
-        const order = astChildOrder(node.kind, name);
         if (order < 0)
             return 0;
         const mask = node.data >>> 30 === 0 ? node.data & 0xff : 0xff;
@@ -165,7 +180,23 @@ export class AstFile {
         }
         return result;
     }
+    /** Reports a read of this file's raw text or line positions. */
+    noteSourceText() {
+        if (sourceTextObserver !== undefined && this.root.kind === SyntaxKind.SourceFile)
+            sourceTextObserver(this.root.fileName);
+    }
+    /** The file name of the source file node at `index`; the root's is
+     * read once. */
+    sourceFileName(index) {
+        if (index === 1 && this.rootFileName !== undefined)
+            return this.rootFileName;
+        const name = this.wire.string(this.wire.extendedWord(index, 4));
+        if (index === 1)
+            this.rootFileName = name;
+        return name;
+    }
     lineStarts() {
+        this.noteSourceText();
         if (this.lines === undefined)
             this.lines = astLineStarts(this.root.text ?? "");
         return this.lines;
@@ -174,6 +205,65 @@ export class AstFile {
 /** Concrete native layout shared by every syntax kind. Kind-specific
  * properties are views over the wire; they never copy identity-bearing
  * nodes into structural records. */
+/* Write targets without their wrappers (AstFileOptions.writeTargets). */
+function isTargetWrapper(node) {
+    return node.kind === AstKind.ParenthesizedExpression || node.kind === AstKind.NonNullExpression;
+}
+function unwrapTarget(node) {
+    let target = node;
+    while (isTargetWrapper(target)) {
+        const inner = target.childNode("expression");
+        if (inner === undefined)
+            break;
+        target = inner;
+    }
+    return target;
+}
+/** Whether `field` of `node` is a write target: an assignment's left side,
+ * a `++`/`--` operand, or a for-in/of head that declares nothing. */
+function writesTarget(node, field) {
+    switch (node.kind) {
+        case AstKind.BinaryExpression: {
+            if (field !== "left")
+                return false;
+            const operator = node.childNode("operatorToken")?.kind;
+            return (operator !== undefined &&
+                operator >= AstKind.FirstAssignment &&
+                operator <= AstKind.LastAssignment);
+        }
+        case AstKind.PrefixUnaryExpression:
+        case AstKind.PostfixUnaryExpression:
+            return (field === "operand" &&
+                (node.operator === AstKind.PlusPlusToken || node.operator === AstKind.MinusMinusToken));
+        case AstKind.ForInStatement:
+        case AstKind.ForOfStatement:
+            return (field === "initializer" &&
+                node.childNode("initializer")?.kind !== AstKind.VariableDeclarationList);
+        default:
+            return false;
+    }
+}
+/** The parent of `node`, whose syntactic parent `wrapper` is a parenthesis
+ * or a non-null assertion: the writer when the wrappers around `node` are
+ * the whole target of an assignment, update or for-in/of head, and
+ * `wrapper` otherwise. */
+function writerOf(node, wrapper) {
+    let outer = wrapper;
+    for (;;) {
+        const up = outer.parent;
+        if (up === undefined)
+            return wrapper;
+        if (isTargetWrapper(up)) {
+            outer = up;
+            continue;
+        }
+        for (const field of ["left", "operand", "initializer"]) {
+            if (writesTarget(up, field) && up.childNode(field) === outer && unwrapTarget(outer) === node)
+                return up;
+        }
+        return wrapper;
+    }
+}
 export class AstNode {
     file;
     index;
@@ -202,7 +292,11 @@ export class AstNode {
     get parent() {
         if (!this.parentResolved) {
             const index = this.file.wire.semanticParent(this.index);
-            this.parentCache = index === 0 || index === this.index ? undefined : this.file.node(index);
+            const parent = index === 0 || index === this.index ? undefined : this.file.node(index);
+            this.parentCache =
+                parent !== undefined && this.file.writeTargets && isTargetWrapper(parent)
+                    ? writerOf(this, parent)
+                    : parent;
             this.parentResolved = true;
         }
         return this.parentCache;
@@ -217,6 +311,23 @@ export class AstNode {
         const index = this.file.namedChild(this, name);
         return index === 0 ? undefined : this.file.node(index);
     }
+    /** childNode by wire slot, as the generated getters select it. */
+    childNodeAt(order) {
+        const index = this.file.namedChildAt(this, order);
+        return index === 0 ? undefined : this.file.node(index);
+    }
+    childListAt(order) {
+        const index = this.file.namedChildAt(this, order);
+        return index === 0 ? undefined : this.file.list(index);
+    }
+    childAt(order) {
+        const index = this.file.namedChildAt(this, order);
+        if (index === 0)
+            return undefined;
+        return this.file.wire.kind(index) === KIND_NODE_LIST
+            ? this.file.list(index)
+            : this.file.node(index);
+    }
     childList(name) {
         const index = this.file.namedChild(this, name);
         return index === 0 ? undefined : this.file.list(index);
@@ -249,6 +360,32 @@ export class AstNode {
         }
     }
     forEachChild(visitNode, visitList) {
+        const wire = this.file.wire;
+        const tree = wire.preorder();
+        if (tree === null)
+            return this.forEachLinkedChild(visitNode, visitList);
+        // In the checked preorder tree, the first child follows its parent and
+        // each later child starts where the previous child's subtree ends.
+        const kinds = tree.kinds;
+        const ends = tree.ends;
+        const stop = ends[this.index];
+        for (let index = this.index + 1; index < stop; index = ends[index]) {
+            const kind = kinds[index];
+            if (kind === PREORDER_LIST) {
+                const result = this.visitChildList(index, visitNode, visitList);
+                if (result)
+                    return result;
+            }
+            else if (kind !== AstKind.JSDoc) {
+                const result = visitNode(this.file.node(index));
+                if (result)
+                    return result;
+            }
+        }
+        return undefined;
+    }
+    /** forEachChild through the sibling and parent links. */
+    forEachLinkedChild(visitNode, visitList) {
         const wire = this.file.wire;
         // Walk the immutable sibling links directly. Repeated semantic scans
         // should not allocate and free a temporary child-index array per node.
@@ -257,19 +394,9 @@ export class AstNode {
                 throw new AstDecodeError("sibling belongs to another parent");
             const kind = wire.kind(index);
             if (kind === KIND_NODE_LIST) {
-                const list = this.file.list(index);
-                if (visitList !== undefined) {
-                    const result = visitList(list);
-                    if (result)
-                        return result;
-                }
-                else {
-                    for (const node of list.nodes) {
-                        const result = visitNode(node);
-                        if (result)
-                            return result;
-                    }
-                }
+                const result = this.visitChildList(index, visitNode, visitList);
+                if (result)
+                    return result;
             }
             else if (kind !== AstKind.JSDoc) {
                 const result = visitNode(this.file.node(index));
@@ -279,6 +406,17 @@ export class AstNode {
         }
         return undefined;
     }
+    visitChildList(index, visitNode, visitList) {
+        const list = this.file.list(index);
+        if (visitList !== undefined)
+            return visitList(list);
+        for (const node of list.nodes) {
+            const result = visitNode(node);
+            if (result)
+                return result;
+        }
+        return undefined;
+    }
     get jsDoc() {
         const docs = [];
         for (const index of this.file.wire.children(this.index)) {
@@ -322,10 +460,15 @@ export class AstNode {
         return this.getStart(sourceFile) - this.pos;
     }
     getFullText(sourceFile) {
-        return ((sourceFile ?? this.file.root).text ?? "").substring(this.pos, this.end);
+        const source = sourceFile ?? this.file.root;
+        source.file.noteSourceText();
+        return (source.text ?? "").substring(this.pos, this.end);
     }
     getText(sourceFile) {
         const source = sourceFile ?? this.file.root;
+        // A token's text is the same in every token-equivalent version.
+        if (this.kind > SyntaxKind.LastToken)
+            source.file.noteSourceText();
         return (source.text ?? "").substring(this.getStart(source), this.end);
     }
     get containsOnlyTriviaWhiteSpaces() {
@@ -424,16 +567,16 @@ export class AstNode {
     }
     get modifierFlags() {
         let result = 0;
-        for (const modifier of this.childList("modifiers")?.nodes ?? [])
+        for (const modifier of this.childListAt(this.modifiersSlot())?.nodes ?? [])
             result |= astModifierFlag(modifier.kind);
         return result;
     }
     get modifiers() {
-        const index = this.file.namedChild(this, "modifiers");
+        const index = this.file.namedChildAt(this, this.modifiersSlot());
         return index === 0 ? undefined : this.file.modifierList(index);
     }
     get body() {
-        const body = this.childNode("body");
+        const body = this.childNodeAt(this.bodySlot());
         // 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.
@@ -450,300 +593,1204 @@ export class AstNode {
         return body;
     }
     get questionToken() {
-        const direct = this.childNode("questionToken");
+        const direct = this.childNodeAt(this.questionTokenSlot());
         if (direct !== undefined)
             return direct;
         // TypeScript 7 shares one postfix slot for optional and definite-
         // assignment declarations. The familiar helper surface keeps them apart.
-        const token = this.childNode("postfixToken");
+        const token = this.postfixToken;
         return token?.kind === SyntaxKind.QuestionToken ? token : undefined;
     }
+    // A write target keeps its parentheses and non-null assertions in the
+    // tree; with AstFileOptions.writeTargets these views return the target
+    // without them.
+    get initializer() {
+        const initializer = this.childNodeAt(this.initializerSlot());
+        return initializer !== undefined && this.file.writeTargets && writesTarget(this, "initializer")
+            ? unwrapTarget(initializer)
+            : initializer;
+    }
+    get left() {
+        const left = this.childNodeAt(this.leftSlot());
+        return left !== undefined && this.file.writeTargets && writesTarget(this, "left")
+            ? unwrapTarget(left)
+            : left;
+    }
+    get operand() {
+        const operand = this.childNodeAt(this.operandSlot());
+        return operand !== undefined && this.file.writeTargets && writesTarget(this, "operand")
+            ? unwrapTarget(operand)
+            : operand;
+    }
     // BEGIN GENERATED CHILD GETTERS
     // Generated from typescript@7.0.2; run scripts/generate-ts7-ast-schema.mjs.
     get argument() {
-        return this.childNode("argument");
+        switch (this.kind) {
+            case 206:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get argumentExpression() {
-        return this.childNode("argumentExpression");
+        switch (this.kind) {
+            case 213:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get arguments() {
-        return this.childList("arguments");
+        switch (this.kind) {
+            case 215:
+                return this.childListAt(2);
+            case 214:
+                return this.childListAt(3);
+            default:
+                return undefined;
+        }
     }
     get assertsModifier() {
-        return this.childNode("assertsModifier");
+        switch (this.kind) {
+            case 183:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get asteriskToken() {
-        return this.childNode("asteriskToken");
+        switch (this.kind) {
+            case 230:
+                return this.childNodeAt(0);
+            case 175:
+            case 219:
+            case 263:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get attributes() {
-        return this.child("attributes");
+        switch (this.kind) {
+            case 301:
+                return this.childAt(0);
+            case 206:
+                return this.childAt(1);
+            case 286:
+            case 287:
+                return this.childAt(2);
+            case 273:
+            case 279:
+            case 343:
+            case 346:
+                return this.childAt(3);
+            default:
+                return undefined;
+        }
     }
     get awaitModifier() {
-        return this.childNode("awaitModifier");
+        switch (this.kind) {
+            case 250:
+            case 251:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get block() {
-        return this.childNode("block");
+        switch (this.kind) {
+            case 300:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get caseBlock() {
-        return this.childNode("caseBlock");
+        switch (this.kind) {
+            case 256:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get catchClause() {
-        return this.childNode("catchClause");
+        switch (this.kind) {
+            case 259:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get checkType() {
-        return this.childNode("checkType");
+        switch (this.kind) {
+            case 195:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get children() {
-        return this.child("children");
+        switch (this.kind) {
+            case 344:
+                return this.childAt(0);
+            case 285:
+            case 289:
+                return this.childAt(1);
+            default:
+                return undefined;
+        }
     }
     get className() {
-        return this.childNode("className");
+        switch (this.kind) {
+            case 323:
+            case 324:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get clauses() {
-        return this.childList("clauses");
+        switch (this.kind) {
+            case 270:
+                return this.childListAt(0);
+            default:
+                return undefined;
+        }
     }
     get closingElement() {
-        return this.childNode("closingElement");
+        switch (this.kind) {
+            case 285:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get closingFragment() {
-        return this.childNode("closingFragment");
+        switch (this.kind) {
+            case 289:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get colonToken() {
-        return this.childNode("colonToken");
+        switch (this.kind) {
+            case 228:
+                return this.childNodeAt(3);
+            default:
+                return undefined;
+        }
     }
     get comment() {
-        return this.childList("comment");
+        switch (this.kind) {
+            case 315:
+                return this.childListAt(0);
+            case 322:
+            case 325:
+            case 326:
+            case 327:
+            case 328:
+            case 329:
+            case 330:
+                return this.childListAt(1);
+            case 323:
+            case 324:
+            case 332:
+            case 334:
+            case 335:
+            case 336:
+            case 339:
+            case 341:
+            case 342:
+                return this.childListAt(2);
+            case 331:
+            case 333:
+            case 337:
+            case 338:
+            case 340:
+                return this.childListAt(3);
+            case 343:
+                return this.childListAt(4);
+            default:
+                return undefined;
+        }
     }
     get condition() {
-        return this.childNode("condition");
+        switch (this.kind) {
+            case 228:
+                return this.childNodeAt(0);
+            case 249:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get constraint() {
-        return this.childNode("constraint");
+        switch (this.kind) {
+            case 337:
+                return this.childNodeAt(1);
+            case 169:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get declarationList() {
-        return this.childNode("declarationList");
+        switch (this.kind) {
+            case 244:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get declarations() {
-        return this.childList("declarations");
+        switch (this.kind) {
+            case 262:
+                return this.childListAt(0);
+            default:
+                return undefined;
+        }
     }
     get defaultType() {
-        return this.childNode("defaultType");
+        switch (this.kind) {
+            case 169:
+                return this.childNodeAt(4);
+            default:
+                return undefined;
+        }
     }
     get dotDotDotToken() {
-        return this.childNode("dotDotDotToken");
+        switch (this.kind) {
+            case 203:
+            case 209:
+            case 295:
+                return this.childNodeAt(0);
+            case 170:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get elementType() {
-        return this.childNode("elementType");
+        switch (this.kind) {
+            case 189:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get elements() {
-        return this.childList("elements");
+        switch (this.kind) {
+            case 190:
+            case 207:
+            case 208:
+            case 210:
+            case 276:
+            case 280:
+                return this.childListAt(0);
+            default:
+                return undefined;
+        }
     }
     get elseStatement() {
-        return this.childNode("elseStatement");
+        switch (this.kind) {
+            case 246:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get endOfFileToken() {
-        return this.childNode("endOfFileToken");
+        switch (this.kind) {
+            case 307:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get equalsGreaterThanToken() {
-        return this.childNode("equalsGreaterThanToken");
+        switch (this.kind) {
+            case 220:
+                return this.childNodeAt(4);
+            default:
+                return undefined;
+        }
     }
     get equalsToken() {
-        return this.childNode("equalsToken");
+        switch (this.kind) {
+            case 304:
+                return this.childNodeAt(4);
+            default:
+                return undefined;
+        }
     }
     get exclamationToken() {
-        return this.childNode("exclamationToken");
+        switch (this.kind) {
+            case 261:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get exportClause() {
-        return this.childNode("exportClause");
+        switch (this.kind) {
+            case 279:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get exprName() {
-        return this.childNode("exprName");
+        switch (this.kind) {
+            case 187:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get expression() {
-        return this.childNode("expression");
+        switch (this.kind) {
+            case 168:
+            case 171:
+            case 212:
+            case 213:
+            case 214:
+            case 215:
+            case 218:
+            case 221:
+            case 222:
+            case 223:
+            case 224:
+            case 231:
+            case 234:
+            case 235:
+            case 236:
+            case 239:
+            case 240:
+            case 245:
+            case 246:
+            case 248:
+            case 254:
+            case 255:
+            case 256:
+            case 258:
+            case 284:
+            case 294:
+            case 297:
+            case 298:
+            case 305:
+            case 348:
+            case 349:
+                return this.childNodeAt(0);
+            case 217:
+            case 230:
+            case 247:
+            case 295:
+                return this.childNodeAt(1);
+            case 250:
+            case 251:
+            case 278:
+                return this.childNodeAt(2);
+            case 169:
+                return this.childNodeAt(3);
+            default:
+                return undefined;
+        }
     }
     get extendsType() {
-        return this.childNode("extendsType");
+        switch (this.kind) {
+            case 195:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get falseType() {
-        return this.childNode("falseType");
+        switch (this.kind) {
+            case 195:
+                return this.childNodeAt(3);
+            default:
+                return undefined;
+        }
     }
     get finallyBlock() {
-        return this.childNode("finallyBlock");
+        switch (this.kind) {
+            case 259:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get head() {
-        return this.childNode("head");
+        switch (this.kind) {
+            case 204:
+            case 229:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get heritageClauses() {
-        return this.childList("heritageClauses");
+        switch (this.kind) {
+            case 232:
+            case 264:
+            case 265:
+                return this.childListAt(3);
+            default:
+                return undefined;
+        }
     }
     get importClause() {
-        return this.childNode("importClause");
+        switch (this.kind) {
+            case 273:
+            case 343:
+            case 346:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get incrementor() {
-        return this.childNode("incrementor");
+        switch (this.kind) {
+            case 249:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get indexType() {
-        return this.childNode("indexType");
-    }
-    get initializer() {
-        return this.childNode("initializer");
+        switch (this.kind) {
+            case 200:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get jsdocPropertyTags() {
-        return this.childNode("jsdocPropertyTags");
+        switch (this.kind) {
+            case 317:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get label() {
-        return this.childNode("label");
-    }
-    get left() {
-        return this.childNode("left");
+        switch (this.kind) {
+            case 252:
+            case 253:
+            case 257:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get literal() {
-        return this.childNode("literal");
+        switch (this.kind) {
+            case 202:
+                return this.childNodeAt(0);
+            case 205:
+            case 240:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get members() {
-        return this.childList("members");
+        switch (this.kind) {
+            case 188:
+                return this.childListAt(0);
+            case 267:
+                return this.childListAt(2);
+            case 232:
+            case 264:
+            case 265:
+                return this.childListAt(4);
+            case 201:
+                return this.childListAt(5);
+            default:
+                return undefined;
+        }
     }
     get moduleReference() {
-        return this.childNode("moduleReference");
+        switch (this.kind) {
+            case 272:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get moduleSpecifier() {
-        return this.childNode("moduleSpecifier");
+        switch (this.kind) {
+            case 273:
+            case 279:
+            case 343:
+            case 346:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get name() {
-        return this.childNode("name");
+        switch (this.kind) {
+            case 237:
+            case 261:
+            case 274:
+            case 275:
+            case 281:
+            case 292:
+            case 302:
+            case 306:
+            case 309:
+            case 319:
+            case 320:
+            case 321:
+                return this.childNodeAt(0);
+            case 169:
+            case 172:
+            case 173:
+            case 174:
+            case 178:
+            case 179:
+            case 203:
+            case 232:
+            case 264:
+            case 265:
+            case 266:
+            case 267:
+            case 268:
+            case 271:
+            case 272:
+            case 277:
+            case 282:
+            case 296:
+            case 303:
+            case 304:
+            case 333:
+            case 340:
+            case 345:
+                return this.childNodeAt(1);
+            case 170:
+            case 175:
+            case 209:
+            case 212:
+            case 219:
+            case 263:
+            case 331:
+            case 338:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get nameExpression() {
-        return this.childNode("nameExpression");
+        switch (this.kind) {
+            case 339:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get nameType() {
-        return this.childNode("nameType");
+        switch (this.kind) {
+            case 201:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get namedBindings() {
-        return this.childNode("namedBindings");
+        switch (this.kind) {
+            case 274:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get namespace() {
-        return this.childNode("namespace");
+        switch (this.kind) {
+            case 296:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get objectAssignmentInitializer() {
-        return this.childNode("objectAssignmentInitializer");
+        switch (this.kind) {
+            case 304:
+                return this.childNodeAt(5);
+            default:
+                return undefined;
+        }
     }
     get objectType() {
-        return this.childNode("objectType");
+        switch (this.kind) {
+            case 200:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get openingElement() {
-        return this.childNode("openingElement");
+        switch (this.kind) {
+            case 285:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get openingFragment() {
-        return this.childNode("openingFragment");
-    }
-    get operand() {
-        return this.childNode("operand");
+        switch (this.kind) {
+            case 289:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get operatorToken() {
-        return this.childNode("operatorToken");
+        switch (this.kind) {
+            case 227:
+                return this.childNodeAt(3);
+            default:
+                return undefined;
+        }
     }
     get parameterName() {
-        return this.childNode("parameterName");
+        switch (this.kind) {
+            case 183:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get parameters() {
-        return this.childList("parameters");
+        switch (this.kind) {
+            case 180:
+            case 181:
+            case 182:
+            case 185:
+            case 318:
+                return this.childListAt(1);
+            case 177:
+            case 186:
+            case 220:
+                return this.childListAt(2);
+            case 178:
+            case 179:
+                return this.childListAt(3);
+            case 174:
+            case 219:
+            case 263:
+                return this.childListAt(4);
+            case 175:
+                return this.childListAt(5);
+            default:
+                return undefined;
+        }
     }
     get postfixToken() {
-        return this.childNode("postfixToken");
+        switch (this.kind) {
+            case 172:
+            case 173:
+            case 174:
+            case 303:
+            case 304:
+                return this.childNodeAt(2);
+            case 175:
+                return this.childNodeAt(3);
+            default:
+                return undefined;
+        }
     }
     get properties() {
-        return this.childList("properties");
+        switch (this.kind) {
+            case 211:
+            case 293:
+                return this.childListAt(0);
+            default:
+                return undefined;
+        }
     }
     get propertyName() {
-        return this.childNode("propertyName");
+        switch (this.kind) {
+            case 277:
+            case 282:
+                return this.childNodeAt(0);
+            case 209:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get qualifier() {
-        return this.childNode("qualifier");
+        switch (this.kind) {
+            case 206:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get questionDotToken() {
-        return this.childNode("questionDotToken");
+        switch (this.kind) {
+            case 212:
+            case 213:
+            case 214:
+            case 216:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get readonlyToken() {
-        return this.childNode("readonlyToken");
+        switch (this.kind) {
+            case 201:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get right() {
-        return this.childNode("right");
+        switch (this.kind) {
+            case 167:
+                return this.childNodeAt(1);
+            case 227:
+                return this.childNodeAt(4);
+            default:
+                return undefined;
+        }
     }
     get statement() {
-        return this.childNode("statement");
+        switch (this.kind) {
+            case 247:
+                return this.childNodeAt(0);
+            case 248:
+            case 255:
+            case 257:
+                return this.childNodeAt(1);
+            case 249:
+            case 250:
+            case 251:
+                return this.childNodeAt(3);
+            default:
+                return undefined;
+        }
     }
     get statements() {
-        return this.childList("statements");
+        switch (this.kind) {
+            case 242:
+            case 269:
+            case 307:
+                return this.childListAt(0);
+            case 297:
+            case 298:
+                return this.childListAt(1);
+            default:
+                return undefined;
+        }
     }
     get tag() {
-        return this.childNode("tag");
+        switch (this.kind) {
+            case 216:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get tagName() {
-        return this.childNode("tagName");
+        switch (this.kind) {
+            case 286:
+            case 287:
+            case 288:
+            case 322:
+            case 323:
+            case 324:
+            case 325:
+            case 326:
+            case 327:
+            case 328:
+            case 329:
+            case 330:
+            case 331:
+            case 332:
+            case 333:
+            case 334:
+            case 335:
+            case 336:
+            case 337:
+            case 338:
+            case 339:
+            case 340:
+            case 341:
+            case 342:
+            case 343:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get tags() {
-        return this.childList("tags");
+        switch (this.kind) {
+            case 315:
+                return this.childListAt(1);
+            default:
+                return undefined;
+        }
     }
     get template() {
-        return this.childNode("template");
+        switch (this.kind) {
+            case 216:
+                return this.childNodeAt(3);
+            default:
+                return undefined;
+        }
     }
     get templateSpans() {
-        return this.childList("templateSpans");
+        switch (this.kind) {
+            case 204:
+            case 229:
+                return this.childListAt(1);
+            default:
+                return undefined;
+        }
     }
     get thenStatement() {
-        return this.childNode("thenStatement");
+        switch (this.kind) {
+            case 246:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get thisArg() {
-        return this.childNode("thisArg");
+        switch (this.kind) {
+            case 349:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get trueType() {
-        return this.childNode("trueType");
+        switch (this.kind) {
+            case 195:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get tryBlock() {
-        return this.childNode("tryBlock");
+        switch (this.kind) {
+            case 259:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get tupleNameSource() {
-        return this.childNode("tupleNameSource");
+        switch (this.kind) {
+            case 238:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get type() {
-        return this.childNode("type");
+        switch (this.kind) {
+            case 191:
+            case 192:
+            case 197:
+            case 199:
+            case 205:
+            case 217:
+            case 308:
+            case 311:
+            case 312:
+            case 313:
+            case 314:
+                return this.childNodeAt(0);
+            case 235:
+            case 239:
+            case 278:
+                return this.childNodeAt(1);
+            case 180:
+            case 181:
+            case 182:
+            case 183:
+            case 185:
+            case 227:
+            case 261:
+            case 318:
+                return this.childNodeAt(2);
+            case 172:
+            case 173:
+            case 177:
+            case 186:
+            case 203:
+            case 220:
+            case 266:
+            case 303:
+            case 304:
+            case 345:
+                return this.childNodeAt(3);
+            case 170:
+            case 178:
+            case 179:
+            case 201:
+                return this.childNodeAt(4);
+            case 174:
+            case 219:
+            case 263:
+                return this.childNodeAt(5);
+            case 175:
+                return this.childNodeAt(6);
+            default:
+                return undefined;
+        }
     }
     get typeArguments() {
-        return this.childList("typeArguments");
+        switch (this.kind) {
+            case 184:
+            case 187:
+            case 215:
+            case 234:
+            case 286:
+            case 287:
+                return this.childListAt(1);
+            case 214:
+            case 216:
+                return this.childListAt(2);
+            case 206:
+                return this.childListAt(3);
+            default:
+                return undefined;
+        }
     }
     get typeExpression() {
-        return this.childNode("typeExpression");
+        switch (this.kind) {
+            case 331:
+            case 332:
+            case 334:
+            case 335:
+            case 336:
+            case 338:
+            case 341:
+            case 342:
+                return this.childNodeAt(1);
+            case 333:
+            case 340:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
     }
     get typeName() {
-        return this.childNode("typeName");
+        switch (this.kind) {
+            case 184:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get typeParameter() {
-        return this.childNode("typeParameter");
+        switch (this.kind) {
+            case 196:
+                return this.childNodeAt(0);
+            case 201:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get typeParameters() {
-        return this.childList("typeParameters");
+        switch (this.kind) {
+            case 180:
+            case 181:
+            case 185:
+            case 318:
+                return this.childListAt(0);
+            case 177:
+            case 186:
+            case 220:
+                return this.childListAt(1);
+            case 178:
+            case 179:
+            case 232:
+            case 264:
+            case 265:
+            case 266:
+            case 337:
+            case 345:
+                return this.childListAt(2);
+            case 174:
+            case 219:
+            case 263:
+                return this.childListAt(3);
+            case 175:
+                return this.childListAt(4);
+            default:
+                return undefined;
+        }
     }
     get types() {
-        return this.childList("types");
+        switch (this.kind) {
+            case 193:
+            case 194:
+            case 299:
+                return this.childListAt(0);
+            default:
+                return undefined;
+        }
     }
     get value() {
-        return this.childNode("value");
+        switch (this.kind) {
+            case 302:
+                return this.childNodeAt(1);
+            default:
+                return undefined;
+        }
     }
     get variableDeclaration() {
-        return this.childNode("variableDeclaration");
+        switch (this.kind) {
+            case 300:
+                return this.childNodeAt(0);
+            default:
+                return undefined;
+        }
     }
     get whenFalse() {
-        return this.childNode("whenFalse");
+        switch (this.kind) {
+            case 228:
+                return this.childNodeAt(4);
+            default:
+                return undefined;
+        }
     }
     get whenTrue() {
-        return this.childNode("whenTrue");
+        switch (this.kind) {
+            case 228:
+                return this.childNodeAt(2);
+            default:
+                return undefined;
+        }
+    }
+    bodySlot() {
+        switch (this.kind) {
+            case 176:
+                return 1;
+            case 268:
+                return 2;
+            case 177:
+                return 4;
+            case 178:
+            case 179:
+            case 220:
+                return 5;
+            case 219:
+            case 263:
+                return 6;
+            case 175:
+                return 7;
+            default:
+                return -1;
+        }
+    }
+    initializerSlot() {
+        switch (this.kind) {
+            case 249:
+                return 0;
+            case 250:
+            case 251:
+            case 292:
+            case 306:
+                return 1;
+            case 209:
+            case 261:
+                return 3;
+            case 172:
+            case 173:
+            case 303:
+                return 4;
+            case 170:
+                return 5;
+            default:
+                return -1;
+        }
+    }
+    leftSlot() {
+        switch (this.kind) {
+            case 167:
+                return 0;
+            case 227:
+                return 1;
+            default:
+                return -1;
+        }
+    }
+    modifiersSlot() {
+        switch (this.kind) {
+            case 169:
+            case 170:
+            case 172:
+            case 173:
+            case 174:
+            case 175:
+            case 176:
+            case 177:
+            case 178:
+            case 179:
+            case 182:
+            case 186:
+            case 219:
+            case 220:
+            case 227:
+            case 232:
+            case 244:
+            case 263:
+            case 264:
+            case 265:
+            case 266:
+            case 267:
+            case 268:
+            case 271:
+            case 272:
+            case 273:
+            case 278:
+            case 279:
+            case 283:
+            case 303:
+            case 304:
+            case 345:
+            case 346:
+                return 0;
+            default:
+                return -1;
+        }
+    }
+    operandSlot() {
+        switch (this.kind) {
+            case 225:
+            case 226:
+                return 0;
+            default:
+                return -1;
+        }
+    }
+    questionTokenSlot() {
+        switch (this.kind) {
+            case 228:
+                return 1;
+            case 203:
+                return 2;
+            case 170:
+            case 201:
+                return 3;
+            default:
+                return -1;
+        }
     }
     // 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));
+        return this.file.sourceFileName(this.index);
     }
     get path() {
         return this.file.wire.string(this.file.wire.extendedWord(this.index, 8));