tsc-ts 0.1.1 → 0.1.3

package/dist/api/compiler/checker-heritage.js

@@ -668,17 +668,18 @@ function areTypeParametersIdentical(c, lists, targetParameters) {
  * (with `checkPrivateNames`) private names shared by static and instance members.
  */
 export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNames) {
-    const instanceNames = new Map();
-    const staticNames = new Map();
-    const privateNames = new Map();
+    // Only a symbol with several declarations can be a duplicate, so the maps are created for the first one.
+    let instanceNames;
+    let staticNames;
+    let privateNames;
     const nodeInAmbientContext = (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
     for (const member of getMembers(node).nodes) {
         if (member.kind === 178 /* SyntaxKind.Constructor */) {
             for (const param of getParameters(member).nodes)
                 if (isParameterPropertyDeclaration(param, member) && !isBindingPattern(getName(param))) {
                     const symbol = getSymbolOfDeclaration(c, param);
-                    if (symbol !== undefined)
-                        checkPropertyOrAccessor(c, node, instanceNames, symbol, 1 /* MemberKind.Property */, false);
+                    if (symbol !== undefined && declarationCount(symbol) > 1)
+                        checkPropertyOrAccessor(c, node, (instanceNames ??= new Map()), symbol, 1 /* MemberKind.Property */, false);
                 }
             continue;
         }
@@ -688,17 +689,22 @@ export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNam
         const memberIsStatic = hasStaticModifier(member);
         if (!nodeInAmbientContext && memberIsStatic && symbol.name === 'prototype')
             c.error(getName(member), 838 /* Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1 */, symbol.name, symbolToString(c, getSymbolOfDeclaration(c, node)));
-        const names = memberIsStatic ? staticNames : instanceNames;
-        const hasAccessorModifier = hasSyntacticModifier(member, 512 /* ModifierFlags.Accessor */);
-        if ((member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !hasAccessorModifier) ||
-            member.kind === 173 /* SyntaxKind.PropertySignature */)
-            checkPropertyOrAccessor(c, node, names, symbol, 1 /* MemberKind.Property */, memberIsStatic);
-        else if (member.kind === 179 /* SyntaxKind.GetAccessor */ ||
-            member.kind === 180 /* SyntaxKind.SetAccessor */ ||
-            (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasAccessorModifier))
-            checkPropertyOrAccessor(c, node, names, symbol, 2 /* MemberKind.Accessor */, memberIsStatic);
+        if (declarationCount(symbol) > 1) {
+            const names = memberIsStatic
+                ? (staticNames ??= new Map())
+                : (instanceNames ??= new Map());
+            const hasAccessorModifier = hasSyntacticModifier(member, 512 /* ModifierFlags.Accessor */);
+            if ((member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !hasAccessorModifier) ||
+                member.kind === 173 /* SyntaxKind.PropertySignature */)
+                checkPropertyOrAccessor(c, node, names, symbol, 1 /* MemberKind.Property */, memberIsStatic);
+            else if (member.kind === 179 /* SyntaxKind.GetAccessor */ ||
+                member.kind === 180 /* SyntaxKind.SetAccessor */ ||
+                (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasAccessorModifier))
+                checkPropertyOrAccessor(c, node, names, symbol, 2 /* MemberKind.Accessor */, memberIsStatic);
+        }
         const name = getName(member);
         if (checkPrivateNames && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
+            privateNames ??= new Map();
             let flags = privateNames.get(symbol.name) ?? 0;
             if (flags === 3)
                 continue;

package/dist/api/compiler/checker-modules.js

@@ -1525,7 +1525,8 @@ function getSymbolFlagsExcludingTypeOnly(c, symbol) {
 }
 /** `getSymbolFlags`, optionally stopping at type-only aliases or leaving out the symbol's own flags. */
 function getSymbolFlagsEx(c, symbol, excludeTypeOnlyMeanings, excludeLocalMeanings) {
-    const seen = new Set();
+    // Only a chain of aliases needs the set, so most calls never create it.
+    let seen;
     let flags = excludeLocalMeanings ? 0 /* SymbolFlags.None */ : symbol.flags;
     while ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
         if (excludeTypeOnlyMeanings && getTypeOnlyAliasDeclaration(c, symbol) !== undefined)
@@ -1534,8 +1535,9 @@ function getSymbolFlagsEx(c, symbol, excludeTypeOnlyMeanings, excludeLocalMeanin
         if (target === c.unknownSymbol)
             return 1073741823 /* SymbolFlags.All */;
         if ((target.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
-            if (target === symbol || seen.has(target))
+            if (target === symbol || seen?.has(target))
                 break;
+            seen ??= new Set();
             seen.add(symbol);
             seen.add(target);
         }

package/dist/api/compiler/checker-narrowing.d.ts

@@ -112,6 +112,13 @@ export declare function getEvolvingArrayType(c: Checker, elementType: Type): Typ
 export declare function isEvolvingArrayOperationTarget(c: Checker, node: Node): boolean;
 /** The array type an evolving array settles on; `any[]` while it has no elements. */
 export declare function finalizeEvolvingArrayType(c: Checker, t: Type): Type;
+/**
+ * Ends the narrowing stopped in `body`, whose checks have finished: what follows the body starts over.
+ * A walk that stopped in another body keeps its body's narrowing stopped.
+ */
+export declare function endFlowAnalysisStop(c: Checker, body: Node): void;
+/** Whether `node` is the body of a function or a module, where flow analysis starts over (flowAnalysisDisabled). */
+export declare function isFunctionOrModuleBlock(node: Node): boolean;
 /**
  * The type of `symbol` at `location`. A destructured variable of a const declaration or unassigned
  * parameter is narrowed by checks of its siblings: in `const { kind, payload } = action`, testing

package/dist/api/compiler/checker-narrowing.js

@@ -182,7 +182,7 @@ export function getFlowTypeOfReference(c, reference, declaredType, initialType,
 }
 /** `getFlowTypeOfReference` at `flowNode`, for pseudo-references such as binding patterns. */
 export function getFlowTypeOfReferenceAt(c, reference, declaredType, initialType, flowContainer, flowNode) {
-    if (c.flowAnalysisDisabled)
+    if (c.flowAnalysisDisabled && isInFlowAnalysisStop(c, reference))
         return c.errorType;
     if (flowNode === undefined)
         return declaredType;
@@ -211,7 +211,7 @@ export function getFlowTypeOfReferenceAt(c, reference, declaredType, initialType
         f.steps >= minFlowWalkSteps &&
         !f.incomplete &&
         !f.positional &&
-        !c.flowAnalysisDisabled &&
+        !(c.flowAnalysisDisabled && isInFlowAnalysisStop(c, reference)) &&
         c.resolutionCycleCount === cycles) {
         const walk = f.walk;
         if (walk !== undefined) {
@@ -248,6 +248,7 @@ function complete(f, t) {
 export function getTypeAtFlowNode(c, f, start) {
     if (f.depth === 2000) {
         c.flowAnalysisDisabled = true;
+        c.flowAnalysisDisabledBody = getContainingFlowBody(f.reference);
         reportFlowControlError(c, f.reference);
         return complete(f, c.errorType);
     }
@@ -2759,17 +2760,43 @@ function getContextFreeTypeOfExpression(c, node) {
     links.contextFreeType = t;
     return t;
 }
-function reportFlowControlError(c, node) {
+/** The body whose walk reached the flow limit, or undefined when no body is stopped. */
+function getContainingFlowBody(node) {
     let block = node;
     while (block !== undefined && !isFunctionOrModuleBlock(block))
         block = block.parent;
+    return block;
+}
+/** Whether `node` is in the body whose walk reached the flow limit, or in a body it contains. */
+function isInFlowAnalysisStop(c, node) {
+    const stop = c.flowAnalysisDisabledBody;
+    if (stop === undefined)
+        return false;
+    for (let n = node; n !== undefined; n = n.parent)
+        if (n === stop)
+            return true;
+    return false;
+}
+/**
+ * Ends the narrowing stopped in `body`, whose checks have finished: what follows the body starts over.
+ * A walk that stopped in another body keeps its body's narrowing stopped.
+ */
+export function endFlowAnalysisStop(c, body) {
+    if (c.flowAnalysisDisabledBody !== body)
+        return;
+    c.flowAnalysisDisabled = false;
+    c.flowAnalysisDisabledBody = undefined;
+}
+function reportFlowControlError(c, node) {
+    const block = getContainingFlowBody(node);
     if (block === undefined)
         return;
     const file = getSourceFileOfNode(node);
     const span = getRangeOfTokenAtPosition(file, getStatements(block).pos);
     c.addDiagnostic(new Diagnostic(file.diagnosticFile(), span.pos, span.end, 724 /* Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis */, []));
 }
-function isFunctionOrModuleBlock(node) {
+/** Whether `node` is the body of a function or a module, where flow analysis starts over (flowAnalysisDisabled). */
+export function isFunctionOrModuleBlock(node) {
     return (node.kind === 308 /* SyntaxKind.SourceFile */ ||
         node.kind === 270 /* SyntaxKind.ModuleBlock */ ||
         (node.kind === 243 /* SyntaxKind.Block */ && node.parent !== undefined && isFunctionLike(node.parent)));

package/dist/api/compiler/checker-source-file.js

@@ -43,6 +43,11 @@ import { checkContextualDeprecations, checkDeprecatedTypeReference } from './che
  * identifiers, which need the whole file checked first.
  */
 export function checkSourceFile(c, file, checkUnused = false) {
+    // A source file is a module body: narrowing stopped by a body too large for control flow analysis
+    // (flowAnalysisDisabled, checker-narrowing.ts) starts over in the next check. A checker checks many files
+    // (parallel-check.ts), so its diagnostics of a file must not depend on the files it checked before it.
+    c.flowAnalysisDisabled = false;
+    c.flowAnalysisDisabledBody = undefined;
     const links = c.nodeLinks(file);
     if ((links.flags & 1 /* NodeCheckFlags.TypeChecked */) === 0) {
         links.flags |= 1 /* NodeCheckFlags.TypeChecked */;
@@ -52,6 +57,9 @@ export function checkSourceFile(c, file, checkUnused = false) {
         links.flags |= 2 /* NodeCheckFlags.UnusedChecked */;
         checkUnusedIdentifiers(c, file);
     }
+    // Every body of the file has finished its checks; a stop recorded for one of them ends with the file.
+    c.flowAnalysisDisabled = false;
+    c.flowAnalysisDisabledBody = undefined;
 }
 function checkSourceFileWorker(c, file) {
     c.fileBeingChecked = file;
@@ -89,6 +97,10 @@ function checkSourceFileWorker(c, file) {
  */
 export function checkSourceFileRange(c, file, start, end) {
     const statements = getStatements(file).nodes;
+    // A range of a file's statements is part of its module body: narrowing stopped by a body too large for
+    // control flow analysis (flowAnalysisDisabled, checker-narrowing.ts) starts over in the next range.
+    c.flowAnalysisDisabled = false;
+    c.flowAnalysisDisabledBody = undefined;
     c.fileBeingChecked = file;
     for (let i = start; i < end; i++)
         checkSourceElement(c, statements[i]);
@@ -106,6 +118,9 @@ export function checkSourceFileRange(c, file, start, end) {
     produceDeferredDiagnostics(c);
     // Deferred nodes of a later range are queued again (checkNodeDeferred).
     c.nodeLinks(file).deferredNodes = undefined;
+    // The range's bodies have finished their checks; a stop recorded for one of them ends with the range.
+    c.flowAnalysisDisabled = false;
+    c.flowAnalysisDisabledBody = undefined;
     return c.diagnostics.forFile(file.fileName).length > 0;
 }
 /**
@@ -520,7 +535,7 @@ function checkTypeMemberAccessor(c, node) {
 /** Variadic tuple elements must be array-like. */
 function checkTupleRestElements(c, node) {
     for (const e of node.elements.nodes) {
-        if ((getTupleElementFlags(c, e) & 8 /* ElementFlags.Variadic */) === 0)
+        if ((getTupleElementFlags(e) & 8 /* ElementFlags.Variadic */) === 0)
             continue;
         if (!isArrayLikeType(c, getTypeFromTypeNode(c, getType(e)))) {
             c.error(e, 732 /* Diagnostics.A_rest_element_type_must_be_an_array_type */);

package/dist/api/compiler/checker-statements.js

@@ -7,7 +7,7 @@ import { checkIteratedTypeOrElementType } from './checker-iteration.js';
 import { checkDestructuringAssignment } from './checker-destructuring.js';
 import { checkReferenceExpression, checkTestingKnownTruthyType, checkTruthinessExpression, isTypeEqualityComparableTo, } from './checker-operators.js';
 import { checkTypeComparableTo, isTypeAssignableTo } from './relations.js';
-import { isReachableFlowNode } from './checker-narrowing.js';
+import { endFlowAnalysisStop, isFunctionOrModuleBlock, isReachableFlowNode } from './checker-narrowing.js';
 import { getIndexType, isTypeAssignableToKindEx as isTypeAssignableToKind } from './checker-type-operators.js';
 import { getExtractStringType } from './checker-symbol-types.js';
 import { checkSourceElement } from './checker-source-file.js';
@@ -21,8 +21,17 @@ import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
 import { typeToString } from './type-printer.js';
 import { getNonNullableType, hasTypeFacts } from './checker-flow.js';
 export function checkBlock(c, node) {
-    for (const s of getStatements(node).nodes)
+    const statements = getStatements(node).nodes;
+    if (!isFunctionOrModuleBlock(node)) {
+        for (const s of statements)
+            checkSourceElement(c, s);
+        return;
+    }
+    // A body too large for control flow analysis stops narrowing in the rest of that body only
+    // (flowAnalysisDisabled, checker-narrowing.ts); what follows the body starts over.
+    for (const s of statements)
         checkSourceElement(c, s);
+    endFlowAnalysisStop(c, node);
 }
 export function checkExpressionStatement(c, node) {
     checkExpression(c, getExpression(node));

package/dist/api/compiler/checker-type-factory.js

@@ -1749,18 +1749,27 @@ export function intersectTypes(c, type1, type2) {
 export function getIntersectionType(c, types) {
     return getIntersectionTypeEx(c, types, 0 /* IntersectionFlags.None */, undefined);
 }
+/**
+ * The distinct types of an intersection, in the order they were added. Most intersections have a few
+ * types, which a scan of `values` finds faster than a `Set` costs to build, so the set is created only
+ * once the list grows past `INDEX_AFTER`.
+ */
 class OrderedTypeSet {
+    static INDEX_AFTER = 8;
     values = [];
-    seen = new Set();
+    index;
     includes = 0;
     has(t) {
-        return this.seen.has(t);
+        return this.index !== undefined ? this.index.has(t) : this.values.includes(t);
     }
     add(t) {
-        if (!this.seen.has(t)) {
-            this.seen.add(t);
-            this.values.push(t);
-        }
+        if (this.has(t))
+            return;
+        this.values.push(t);
+        if (this.index !== undefined)
+            this.index.add(t);
+        else if (this.values.length > OrderedTypeSet.INDEX_AFTER)
+            this.index = new Set(this.values);
     }
 }
 function addTypesToIntersection(c, set, types) {
@@ -2126,7 +2135,8 @@ function getCrossProductIntersections(c, types, flags) {
  */
 function addCrossProductIntersections(c, types, flags, constituents, index, unit, intersections) {
     if (index === types.length) {
-        const t = getIntersectionTypeEx(c, constituents.slice(), flags, undefined);
+        // getIntersectionTypeEx copies the types it keeps, so the buffer is reused for the next combination.
+        const t = getIntersectionTypeEx(c, constituents, flags, undefined);
         if ((t.flags & 262144 /* TypeFlags.Never */) === 0)
             intersections.push(t);
         return;

package/dist/api/compiler/checker-type-nodes.d.ts

@@ -20,7 +20,7 @@ export declare function isTypeAlias(node: Node): boolean;
 export declare function getAliasForTypeNode(c: Checker, node: Node): TypeAlias | undefined;
 export declare function getAliasSymbolForTypeNode(c: Checker, node: Node): Symbol | undefined;
 export declare function getTypeAliasInstantiation(c: Checker, symbol: Symbol, typeArguments: Type[], alias: TypeAlias | undefined): Type;
-export declare function getTupleElementFlags(c: Checker, node: Node): ElementFlags;
+export declare function getTupleElementFlags(node: Node): ElementFlags;
 /** Type arguments of a deferred reference from its node. */
 export declare function getTypeArgumentsOfDeferredReference(c: Checker, node: Node, target: InterfaceType): Type[];
 /** The symbol an identifier resolves to, cached on the identifier. */

package/dist/api/compiler/checker-type-nodes.js

@@ -711,7 +711,7 @@ function getTypeFromTypeQueryNode(c, node) {
     }
     return type;
 }
-export function getTupleElementFlags(c, node) {
+export function getTupleElementFlags(node) {
     switch (node.kind) {
         case 192 /* SyntaxKind.OptionalType */:
             return 2 /* ElementFlags.Optional */;
@@ -730,8 +730,8 @@ export function getTupleElementFlags(c, node) {
     }
     return 1 /* ElementFlags.Required */;
 }
-function getTupleElementInfo(c, node) {
-    return new TupleElementInfo(getTupleElementFlags(c, node), node.kind === 204 /* SyntaxKind.NamedTupleMember */ || node.kind === 171 /* SyntaxKind.Parameter */ ? node : undefined);
+function getTupleElementInfo(node) {
+    return new TupleElementInfo(getTupleElementFlags(node), node.kind === 204 /* SyntaxKind.NamedTupleMember */ || node.kind === 171 /* SyntaxKind.Parameter */ ? node : undefined);
 }
 function getArrayElementTypeNode(node) {
     switch (node.kind) {
@@ -760,7 +760,7 @@ function getArrayOrTupleTargetType(c, node) {
         return readonly ? c.globalReadonlyArrayType : c.globalArrayType;
     const elementInfos = [];
     for (const e of node.elements.nodes)
-        elementInfos.push(getTupleElementInfo(c, e));
+        elementInfos.push(getTupleElementInfo(e));
     return getTupleTargetType(c, elementInfos, readonly);
 }
 function getTypeFromArrayOrTupleTypeNode(c, node) {
@@ -787,7 +787,7 @@ function getTypeFromArrayOrTupleTypeNode(c, node) {
 }
 function hasVariadicTupleElement(c, node) {
     for (const e of node.elements.nodes)
-        if ((getTupleElementFlags(c, e) & 8 /* ElementFlags.Variadic */) !== 0)
+        if ((getTupleElementFlags(e) & 8 /* ElementFlags.Variadic */) !== 0)
             return true;
     return false;
 }

package/dist/api/compiler/checker-unused.js

@@ -326,8 +326,9 @@ function checkUnusedLocalsAndParameters(c, node) {
     const locals = getLocals(node);
     if (locals === undefined)
         return;
-    const variableParents = new Set();
-    const importClauses = new Map();
+    // Created on the first unused declaration: most scopes have none.
+    let variableParents;
+    let importClauses;
     for (const local of locals.values()) {
         const referenceKinds = c.symbolReferenceKinds.get(getSymbolId(local));
         if ((local.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0) {
@@ -343,6 +344,7 @@ function checkUnusedLocalsAndParameters(c, node) {
                 case 262 /* SyntaxKind.VariableDeclaration */:
                 case 171 /* SyntaxKind.Parameter */:
                 case 210 /* SyntaxKind.BindingElement */:
+                    variableParents ??= new Set();
                     variableParents.add(getRootDeclaration(declaration).parent);
                     break;
                 case 275 /* SyntaxKind.ImportClause */:
@@ -350,6 +352,7 @@ function checkUnusedLocalsAndParameters(c, node) {
                 case 276 /* SyntaxKind.NamespaceImport */:
                     if (!isIdentifierThatStartsWithUnderscore(getName(declaration))) {
                         const importClause = importClauseFromImported(declaration);
+                        importClauses ??= new Map();
                         const unuseds = importClauses.get(importClause);
                         if (unuseds === undefined)
                             importClauses.set(importClause, [declaration]);
@@ -363,14 +366,16 @@ function checkUnusedLocalsAndParameters(c, node) {
             }
         }
     }
-    for (const declaration of variableParents) {
-        if (declaration.kind === 263 /* SyntaxKind.VariableDeclarationList */)
-            reportUnusedVariables(c, declaration, declaration.declarations.nodes);
-        else
-            reportUnusedVariableDeclarations(c, getParameters(declaration).nodes);
-    }
-    for (const [declaration, unuseds] of importClauses)
-        reportUnusedImports(c, declaration, unuseds);
+    if (variableParents !== undefined)
+        for (const declaration of variableParents) {
+            if (declaration.kind === 263 /* SyntaxKind.VariableDeclarationList */)
+                reportUnusedVariables(c, declaration, declaration.declarations.nodes);
+            else
+                reportUnusedVariableDeclarations(c, getParameters(declaration).nodes);
+        }
+    if (importClauses !== undefined)
+        for (const [declaration, unuseds] of importClauses)
+            reportUnusedImports(c, declaration, unuseds);
 }
 function reportUnusedLocal(c, node, name) {
     const message = isTypeDeclaration(node)

package/dist/api/compiler/checker.d.ts

@@ -155,6 +155,8 @@ export declare class Checker implements TypeChecking {
     readonly noUncheckedIndexedAccess: boolean;
     typeCount: number;
     signatureCount: number;
+    /** Transient symbols the checker created (statistics), as tsgo's `Checker.SymbolCount`. */
+    symbolCount: number;
     /** Positions of members by name in the tables and lists that lazily instantiated members come from. */
     readonly memberPositionsInLists: Map<Symbol[], Map<string, number>>;
     /** The property names of the last instantiation of each such list whose table is built on demand. */
@@ -464,6 +466,8 @@ export declare class Checker implements TypeChecking {
     /** `{ meta: ImportMeta }`, the type of `import.meta` for symbol queries. */
     importMetaExpressionType: Type | undefined;
     flowAnalysisDisabled: boolean;
+    /** The body whose walk reached the flow limit (flowAnalysisDisabled), until its checks finish. */
+    flowAnalysisDisabledBody: Node | undefined;
     inlineLevel: number;
     /**
      * Shared flow nodes cached by the walks in progress, with their types: the first

package/dist/api/compiler/checker.js

@@ -282,6 +282,8 @@ export class Checker {
     // Counters for type and signature ids.
     typeCount = 0;
     signatureCount = 0;
+    /** Transient symbols the checker created (statistics), as tsgo's `Checker.SymbolCount`. */
+    symbolCount = 0;
     /** Positions of members by name in the tables and lists that lazily instantiated members come from. */
     memberPositionsInLists = new Map();
     /** The property names of the last instantiation of each such list whose table is built on demand. */
@@ -610,6 +612,8 @@ export class Checker {
     importMetaExpressionType = undefined;
     // Control flow analysis
     flowAnalysisDisabled = false;
+    /** The body whose walk reached the flow limit (flowAnalysisDisabled), until its checks finish. */
+    flowAnalysisDisabledBody = undefined;
     inlineLevel = 0;
     /**
      * Shared flow nodes cached by the walks in progress, with their types: the first
@@ -982,10 +986,12 @@ export class Checker {
         return new TypeParameter(this.nextTypeId(), symbol);
     }
     newSymbol(flags, name) {
+        this.symbolCount++;
         const symbol = new Symbol(flags | 33554432 /* SymbolFlags.Transient */, name);
         return symbol;
     }
     newSymbolWithCheckFlags(flags, name, checkFlags) {
+        this.symbolCount++;
         const symbol = new Symbol(flags | 33554432 /* SymbolFlags.Transient */, name);
         symbol.checkFlags = checkFlags;
         return symbol;

package/dist/api/compiler/file-loader.d.ts

@@ -29,6 +29,11 @@ export declare class CompilerHost extends ModuleResolutionHost {
     readFile(path: string): string | undefined;
     realpath(path: string): string;
     getDirectories(path: string): readonly string[];
+    /**
+     * The metadata of the file `FileLoader` is parsing, which it computes from the file's package scope
+     * before it parses it; a host that walks the grammar of the parsed file reads it (parse-thread.ts).
+     */
+    loadingSourceFileMetadata: SourceFileMetadata | undefined;
     /** Parses a file, or returns `undefined` if it can't be read. */
     getSourceFile(fileName: string, path: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions): SourceFile | undefined;
     /** The config of a referenced project, or `undefined` if it can't be read. */

package/dist/api/compiler/file-loader.js

@@ -51,6 +51,11 @@ export class CompilerHost extends ModuleResolutionHost {
     getDirectories(path) {
         return this.fs.getAccessibleEntries(path).directories;
     }
+    /**
+     * The metadata of the file `FileLoader` is parsing, which it computes from the file's package scope
+     * before it parses it; a host that walks the grammar of the parsed file reads it (parse-thread.ts).
+     */
+    loadingSourceFileMetadata = undefined;
     /** Parses a file, or returns `undefined` if it can't be read. */
     getSourceFile(fileName, path, externalModuleIndicatorOptions) {
         // A file that parse threads prepared (parallel-parse.ts).
@@ -1054,6 +1059,8 @@ export class FileLoader {
                 ? libFileMetadata
                 : (loaded?.metadata ?? this.loadSourceFileMetadata(task.normalizedFilePath));
         const options = this.mapper.getCompilerOptionsForFile(task.path, task.normalizedFilePath);
+        // For the host that walks the grammar of the file as it parses it (parse-thread.ts).
+        this.host.loadingSourceFileMetadata = task.metadata;
         const file = this.host.getSourceFile(task.normalizedFilePath, task.path, getExternalModuleIndicatorOptions(task.normalizedFilePath, options, task.metadata));
         if (file === undefined)
             return;

package/dist/api/compiler/program-checker.d.ts

@@ -88,6 +88,18 @@ export declare class CheckedProgram {
     createChecker(): Checker;
     /** Frees the checker that reports the program's diagnostics (`disposeChecker`). */
     disposeCheckers(): void;
+    /** Adds the counts a checker thread sent (`CheckerResult.counts`): types, instantiations, symbols. */
+    addCheckerCounts(counts: readonly number[]): void;
+    /**
+     * The types, instantiations and transient symbols of every checker of the program: this thread's and
+     * the checker threads', as tsgo's `Program.TypeCount`, `InstantiationCount` and `SymbolCount` add them up.
+     * Reading them doesn't create this thread's checker.
+     */
+    checkerCounts(): {
+        types: number;
+        instantiations: number;
+        symbols: number;
+    };
     getBindDiagnostics(file: SourceFile | undefined): Diagnostic[];
     /**
      * Diagnostics of checker threads (parallel-check.ts): the semantic diagnostics of each file by file
@@ -109,6 +121,12 @@ export declare class CheckedProgram {
      */
     referenceThreads: number;
     readonly parallelGlobalDiagnostics: Diagnostic[];
+    /** The types checker threads created (`CheckerResult.counts`), which `--diagnostics` adds to `checker`'s. */
+    threadTypeCount: number;
+    /** The instantiations checker threads made. */
+    threadInstantiations: number;
+    /** The transient symbols checker threads created. */
+    threadSymbolCount: number;
     /**
      * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
      * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report

package/dist/api/compiler/program-checker.js

@@ -176,6 +176,27 @@ export class CheckedProgram {
             disposeChecker(this.reportingChecker);
         this.reportingChecker = undefined;
     }
+    /** Adds the counts a checker thread sent (`CheckerResult.counts`): types, instantiations, symbols. */
+    addCheckerCounts(counts) {
+        if (counts.length < 3)
+            return;
+        this.threadTypeCount += counts[0];
+        this.threadInstantiations += counts[1];
+        this.threadSymbolCount += counts[2];
+    }
+    /**
+     * The types, instantiations and transient symbols of every checker of the program: this thread's and
+     * the checker threads', as tsgo's `Program.TypeCount`, `InstantiationCount` and `SymbolCount` add them up.
+     * Reading them doesn't create this thread's checker.
+     */
+    checkerCounts() {
+        const own = this.reportingChecker;
+        return {
+            types: (own === undefined ? 0 : own.typeCount) + this.threadTypeCount,
+            instantiations: (own === undefined ? 0 : own.totalInstantiations) + this.threadInstantiations,
+            symbols: (own === undefined ? 0 : own.symbolCount) + this.threadSymbolCount,
+        };
+    }
     getBindDiagnostics(file) {
         return this.collect(file, (f) => f.bindDiagnostics);
     }
@@ -199,6 +220,12 @@ export class CheckedProgram {
      */
     referenceThreads = 1;
     parallelGlobalDiagnostics = [];
+    /** The types checker threads created (`CheckerResult.counts`), which `--diagnostics` adds to `checker`'s. */
+    threadTypeCount = 0;
+    /** The instantiations checker threads made. */
+    threadInstantiations = 0;
+    /** The transient symbols checker threads created. */
+    threadSymbolCount = 0;
     /**
      * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
      * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsc-ts",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "The TypeScript 7 compiler, ported to TypeScript and compiled to a native executable.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,19 +28,24 @@
     },
     "./package.json": "./package.json"
   },
-  "dependencies": {
+  "peerDependencies": {
     "@scriptc/threads": "0.4.8"
   },
+  "peerDependenciesMeta": {
+    "@scriptc/threads": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@tsc-ts/darwin-arm64": "0.1.1",
-    "@tsc-ts/darwin-x64": "0.1.1",
-    "@tsc-ts/linux-arm64-gnu": "0.1.1",
-    "@tsc-ts/linux-arm64-musl": "0.1.1",
-    "@tsc-ts/linux-x64-gnu": "0.1.1",
-    "@tsc-ts/linux-x64-musl": "0.1.1",
-    "@tsc-ts/win32-x64-msvc": "0.1.1"
+    "@tsc-ts/darwin-arm64": "0.1.3",
+    "@tsc-ts/darwin-x64": "0.1.3",
+    "@tsc-ts/linux-arm64-gnu": "0.1.3",
+    "@tsc-ts/linux-arm64-musl": "0.1.3",
+    "@tsc-ts/linux-x64-gnu": "0.1.3",
+    "@tsc-ts/linux-x64-musl": "0.1.3",
+    "@tsc-ts/win32-x64-msvc": "0.1.3"
   }
 }

package/src/compiler/ast.ts

@@ -209,9 +209,14 @@ export abstract class NodeVisitor {
   }
 }
 
-// Native builds store `pos`, `end` and `id` as 32-bit integers when every write provably stores an
-// int32, so writes of values the compiler can't bound (parameters, the id counter) are coerced
-// with `| 0`; the values are always int32.
+// Native builds store `pos`, `end` and `id` as 32-bit integers when every write provably stores
+// an int32, so writes of values the compiler can't bound (parameters, the id counter) are
+// coerced with `| 0`; the values are always int32.
+//
+// The fields of a node that the public API's node types declare are stored fields, not values
+// computed from or packed into another field: a native build copies the stored fields of a node
+// into a record when API code narrows one (`node as StringLiteralLike`), and a field behind an
+// accessor is not copied.
 export abstract class Node implements ProgramLifetime {
   readonly kind: SyntaxKind;
   flags: NodeFlags;
@@ -8244,6 +8249,7 @@ export const emptyCommentDirectives: readonly CommentDirective[] = [];
 export const emptyPragmas: readonly Pragma[] = [];
 export const emptyFileReferences: readonly FileReference[] = [];
 export const emptyPatternAmbientModules: readonly PatternAmbientModule[] = [];
+const emptyNumbers: readonly number[] = [];
 
 /** `list` with `item` appended: a new array when `list` is empty (it may be shared), else `list` itself. */
 export function appendToList<T>(list: readonly T[], item: T): readonly T[] {
@@ -8320,6 +8326,14 @@ export class SourceFile extends Node {
   /** UMD exports from `export as namespace N`. */
   globalExports: SymbolTable | undefined;
 
+  // Set by the grammar checks of a parse thread (checker-grammar.ts).
+  /** The diagnostics the parse thread's grammar walk reported for this file. */
+  grammarDiagnostics: Diagnostic[] | undefined;
+  /** The nodes of this file whose grammar check needs the checker, in tree order. */
+  grammarResidualNodes: Node[] | undefined;
+  /** The blocks and statements that reported a statement in an ambient context. */
+  grammarAmbientReports: readonly number[];
+
   constructor(
     fileName: string,
     path: string,
@@ -8373,6 +8387,9 @@ export class SourceFile extends Node {
     this.symbolCount = 0;
     this.patternAmbientModules = emptyPatternAmbientModules;
     this.globalExports = undefined;
+    this.grammarDiagnostics = undefined;
+    this.grammarResidualNodes = undefined;
+    this.grammarAmbientReports = emptyNumbers;
   }
 
   forEachChild(v: NodeVisitor): boolean {