@scriptc/compiler 0.4.2 → 0.4.3

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

@@ -3,6 +3,14 @@ import { AstKind, AstModifierFlags, AstNodeFlags, KIND_NODE_LIST, astChildOrder,
 import { astLineOfPosition, astLineStarts, astSkipTrivia } from "./ast-text.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
@@ -56,6 +64,8 @@ export class AstFile {
     strings = new Map();
     lines;
     childIndices;
+    /** The root source file's name (AstNode.fileName). */
+    rootFileName;
     /** Whether nodes answer write targets without their wrappers (see
      * AstFileOptions.writeTargets). */
     writeTargets;
@@ -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;
@@ -280,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);
@@ -412,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() {
@@ -514,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.
@@ -540,31 +593,31 @@ 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.childNode("initializer");
+        const initializer = this.childNodeAt(this.initializerSlot());
         return initializer !== undefined && this.file.writeTargets && writesTarget(this, "initializer")
             ? unwrapTarget(initializer)
             : initializer;
     }
     get left() {
-        const left = this.childNode("left");
+        const left = this.childNodeAt(this.leftSlot());
         return left !== undefined && this.file.writeTargets && writesTarget(this, "left")
             ? unwrapTarget(left)
             : left;
     }
     get operand() {
-        const operand = this.childNode("operand");
+        const operand = this.childNodeAt(this.operandSlot());
         return operand !== undefined && this.file.writeTargets && writesTarget(this, "operand")
             ? unwrapTarget(operand)
             : operand;
@@ -572,280 +625,1172 @@ 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");
+        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");
+        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");
+        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");
+        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));