tsc-ts 0.1.2 → 0.1.4

package/README.md

@@ -33,7 +33,7 @@ npx tsc-ts --noEmit src/index.ts
 
 `tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`. On Windows, `--api --pipe \\.\pipe\<name>` serves it over a named pipe it creates, as `tsc --api --pipe` does, for clients that connect to the pipe (such as scriptc under Node.js); only the native executable supports `--pipe`. On macOS and Linux, `--api --listen <path>` serves it on a Unix socket it creates, with mode 0600, to one client of the same user at a time, each until the client closes its end. Each client gets the answers a new `tsc-ts --api` process would give, except that symbol ids continue from earlier clients, and the server reads every file through the client again, but it keeps parsed files between clients and reuses those whose text is unchanged, along with the encoding `getSourceFile` sends for each, so a client that opens the same project again loads it faster. The server exits when no client connects for 60 seconds (`--idle-exit <seconds>` sets the time), or after a client when its resident memory is above 2.5 times what it held after its first client (`TSC_TS_LISTEN_MEMORY` sets the limit in megabytes). To stop, it removes the socket file, serves the clients that had connected, and exits. It replaces a socket file that no server answers on, such as one left by a server that was killed. Only the native executable supports `--listen`. With `--default-libraries-from-disk`, the server reads the files in its default library directory (`TSC_TS_LIB_DIR`, or the executable's directory) from the disk itself, even when the client handles file system calls (`--callbacks`), which saves a round trip to the client for each library file.
 
-`--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1` and in the first build of `--watch`, with or without build info, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. The checker threads share the results they compute where the run expects that to pay: at 12 or more checkers, when 40% of the program's files are declarations or come from `node_modules` and the checkers' ranges mostly resolve the same large libraries. `TSC_TS_SHARE=1` turns sharing on for any program and `TSC_TS_SHARE=0` keeps it off, and a run whose sharing stops paying stops sharing its results as it goes. A sharing run may also bound how many results it posts at a time, which costs a few percent on a project that does not gain by it and saves more on one that does: the learned choice among a project's runs, off until its record shows it faster, and `TSC_TS_SHARE_BOUNDED=1` turns it on for any program while `TSC_TS_SHARE_BOUNDED=0` keeps it off. `TSC_TS_AUTO=0` keeps the choices of a run before automatic selection (fewer checkers where the ranges resolve large libraries, no sharing), and `TSC_TS_AUTO=static` keeps the rules and the in-run switches but reads and writes no records, and `TSC_TS_AUTO=explore` adds the experimental exploration described below. Unless `--singleThreaded` is given, the files are parsed on the CPUs the process may run on, but one, whatever the checker count, and `TSC_TS_PARSE_THREADS` sets how many. `--extendedDiagnostics` prints the checker threads, the sharing and the parse threads after the statistics table, under `Suggestions:`, with where each value came from (`pinned: --checkers`, `default`, `automatic: ...`, `learned: check 14% faster over 3 runs`, `exploring`, `control`) and how to pin it; `--build` prints one section per project it builds. The section also names the run's record under `Records:`. Each run that checks a program writes what it measured to `~/.cache/tsc-ts/runs-v1/` (`TSC_TS_CACHE_DIR` sets the directory, `TSC_TS_CACHE=0` turns records off), for later runs of the same project on the same machine to read. A later run chooses from that record where the rules left a setting open: a configuration the samples show faster than the static choice — by 3% or twice the standard error of the gains each of its samples makes against the nearest run of the other arm, on three samples of each taken while the machine was not busy — is adopted, every sixteenth run (and the first after two weeks) re-measures the static choice as a control run, and an adopted configuration whose last three samples all fall behind the control runs reverts at once. A run never tries a configuration that could make itself slower: it adopts only what the samples already show faster, from `tsc-ts doctor`, from a pinned run or from a run that already used it. `TSC_TS_AUTO=explore` turns on an experimental alternative in which a run also tries a setting the signals leave uncertain: one run in eight tries three quarters of the count where the library text puts it near the cut, sharing at eight checkers near the rule's limits, or half the parse threads, and such a run is slower than the configuration it would have used. A program whose shape changed by more than 15% discards the record's samples. Watch mode, a `--build` of several projects at once, `--singleThreaded`, Node builds and `TSC_TS_AUTO=0` or `static` keep no record, and the section says why; a run with `CI` set reads and adopts but never explores. `tsc-ts doctor [-p <tsconfig>] [--runs N] [--budget SECONDS] [--emit] [--json] [--no-save]` measures these settings on this machine: it runs the project's check under the default configuration, with sharing on, with up to 16 checkers, with both, and with half the parse threads, compares the phase times by the same rule automatic selection uses, and prints what it recommends with the evidence for it. Each measured run is a child process, so it runs as a user's run would, and it writes what it measured to the file named by `TSC_TS_DOCTOR_REPORT`; runs without the variable are unaffected. Doctor stores its samples in the record with role `doctor`, unless `--no-save` is given. The command is experimental: the configurations it compares and what it recommends may change. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
+`--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1` and in the first build of `--watch`, with or without build info, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. The checker threads share the results they compute where the run expects that to pay: at 12 or more checkers, when 40% of the program's files are declarations or come from `node_modules` and the checkers' ranges mostly resolve the same large libraries. `TSC_TS_SHARE=1` turns sharing on for any program and `TSC_TS_SHARE=0` keeps it off, and a run whose sharing stops paying stops sharing its results as it goes. A sharing run may also bound how many results it posts at a time, which costs a few percent on a project that does not gain by it and saves more on one that does: the learned choice among a project's runs, off until its record shows it faster, and `TSC_TS_SHARE_BOUNDED=1` turns it on for any program while `TSC_TS_SHARE_BOUNDED=0` keeps it off. `TSC_TS_AUTO=0` keeps the choices of a run before automatic selection (fewer checkers where the ranges resolve large libraries, no sharing), and `TSC_TS_AUTO=static` keeps the rules and the in-run switches but reads and writes no records, and `TSC_TS_AUTO=explore` adds the experimental exploration described below. Unless `--singleThreaded` is given, the files are parsed on the CPUs the process may run on, but one, whatever the checker count, and `TSC_TS_PARSE_THREADS` sets how many. `--extendedDiagnostics` prints the checker threads, the sharing and the parse threads after the statistics table, under `Suggestions:`, with where each value came from (`pinned: --checkers`, `default`, `automatic: ...`, `learned: check 14% faster over 3 runs`, `exploring`, `control`) and how to pin it; `--build` prints one section per project it builds. The section also names the run's record under `Records:`. Each run that checks a program writes what it measured to `~/.cache/tsc-ts/runs-v1/` (`TSC_TS_CACHE_DIR` sets the directory, `TSC_TS_CACHE=0` turns records off), for later runs of the same project on the same machine to read. A later run chooses from that record where the rules left a setting open: a configuration the samples show faster than the static choice — by 3% or twice the standard error of the gains each of its samples makes against the nearest run of the other arm, on three samples of each taken while the machine was not busy — is adopted, every sixteenth run (and the first after two weeks) re-measures the static choice as a control run, and an adopted configuration whose last three samples all fall behind the control runs reverts at once. A run never tries a configuration that could make itself slower: it adopts only what the samples already show faster, from `tsc-ts doctor`, from a pinned run or from a run that already used it. `TSC_TS_AUTO=explore` turns on an experimental alternative in which a run also tries a setting the signals leave uncertain: one run in eight tries three quarters of the count where the library text puts it near the cut, sharing at eight checkers near the rule's limits, or half the parse threads, and such a run is slower than the configuration it would have used. A program whose shape changed by more than 15% discards the record's samples. Watch mode, a `--build` of several projects at once, `--singleThreaded`, Node builds and `TSC_TS_AUTO=0` or `static` keep no record, and the section says why; a run with `CI` set reads and adopts but never explores. `tsc-ts doctor [-p <tsconfig>] [--runs N] [--budget SECONDS] [--emit] [--json] [--no-save]` measures these settings on this machine: it runs the project's check under the default configuration, with sharing on, with up to 16 checkers, with both, and with half the parse threads, compares the phase times by the same rule automatic selection uses, and prints what it recommends with the evidence for it. Each measured run is a child process, so it runs as a user's run would, and it writes what it measured to the file named by `TSC_TS_DOCTOR_REPORT`; runs without the variable are unaffected. Doctor stores its samples in the record with role `doctor`, unless `--no-save` is given. The command is experimental: the configurations it compares and what it recommends may change. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker, except for the two a check reports when a type instantiation reaches the depth limit: TS5115 on the instantiations, and TS2344 on the constraint check that stops there. Whether a file reaches the limit depends on the declarations its checker has already resolved, and which files a checker has is decided while checking runs, so those two diagnostics are best effort with more than one checker: one run can report them in different files than another run, and a run with one checker can report them where a run with several does not.
 
 The native executable never frees syntax trees, types, signatures or symbols: it keeps them until it exits, which saves the cost of tracking them during a build. A one-shot build is unaffected, but a long-running process grows with each rebuild or project update. Native `--watch` (also with `--build`) runs in a child process, and when a change arrives while that process holds more than 2.5 times the memory it held after its first build, a new process replaces it and builds the change, reporting what the old process would have. `TSC_TS_WATCH_MEMORY` sets that limit in megabytes, and `TSC_TS_WATCH_MEMORY=0` turns the replacement off. A `--api` process grows with each project update; restart it to reclaim the memory.
 

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

@@ -33,7 +33,7 @@ import { couldContainTypeVariables, instantiateSignature } from './instantiation
 import { getContextualSignatureForFunctionLikeDeclaration, getInferenceContext, instantiateContextualType, } from './checker-contextual.js';
 import { checkJSDocFullSignature, checkJSDocFullSignatureType, checkUnmatchedJSDocParameters, getFullSignatureTypeNode, } from './checker-jsdoc.js';
 import { getEffectiveCheckNode, isFunctionLike, nodeIsMissing } from './ast-utilities.js';
-import { getFlowTypeOfReferenceAt, isConstantReference, isReachableFlowNode, isSymbolAssigned, } from './checker-narrowing.js';
+import { endFlowAnalysisStop, getFlowTypeOfReferenceAt, isConstantReference, isReachableFlowNode, isSymbolAssigned, } from './checker-narrowing.js';
 import { FlowNode } from './flow.js';
 import { checkAwaitedType, checkGeneratorInstantiationAssignabilityToReturnType, checkIteratedTypeOrElementType, createGeneratorType, createPromiseReturnType, createPromiseType, getAwaitedTypeEx, getAwaitedTypeNoAlias, getGlobalPromiseTypeChecked, getIterationTypeOfGeneratorFunctionReturnType, getIterationTypeOfIterable, getIterationTypesOfGeneratorFunctionReturnType, getIterationTypesOfIterable, getPromisedTypeOfPromise, isReferenceToType, unwrapAwaitedType, unwrapReturnType, } from './checker-iteration.js';
 import { typeToString } from './type-printer.js';
@@ -274,6 +274,10 @@ export function checkFunctionLikeBody(c, node) {
         if (returnType !== undefined)
             checkReturnExpression(c, node, unwrapReturnType(c, returnType, functionFlags), body, body, exprType, false);
     }
+    // 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. Inferring the
+    // return type above checks the body's return expressions, which can reach the limit.
+    endFlowAnalysisStop(c, body);
 }
 /** Checks a generator's or async function's return type annotation. */
 function checkSignatureReturnType(c, node, returnTypeNode, functionFlags) {

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

@@ -513,9 +513,13 @@ class InferenceState {
         const sourceAlias = source.alias;
         const targetAlias = target.alias;
         if (sourceAlias !== undefined && targetAlias !== undefined && sourceAlias.symbol === targetAlias.symbol) {
-            // Instantiations of the same alias infer between their type arguments, once for each pair of types, as tsc does.
+            // Instantiations of the same alias infer between their type arguments, once for each pair of types, as tsc
+            // does. The pair is memoized, which keeps inference from type arguments from repeating exponentially (tsgo
+            // #64378), but it does not take part in invokeOnce's recursion-identity check: the identities of a recursive
+            // alias repeat through its properties, and below such a property that check reports a circularity and skips
+            // an inference that tsc 7.0.2 makes (#418).
             if (sourceAlias.typeArguments.length !== 0 || targetAlias.typeArguments.length !== 0)
-                this.invokeOnce(source, target, 0 /* InferenceAction.AliasTypeArguments */);
+                this.invokeOnce(source, target, 0 /* InferenceAction.AliasTypeArguments */, false);
             return;
         }
         if (source === target && (source.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
@@ -718,8 +722,13 @@ class InferenceState {
         else
             this.inferFromTypes(source, target);
     }
-    /** Runs `action` once per source and target pair, stopping at circularities. */
-    invokeOnce(source, target, action) {
+    /**
+     * Runs `action` once per source and target pair, stopping at circularities. With `checkRecursion` false, the pair
+     * is still memoized but its action neither joins the recursion stacks nor stops at the recursion identities the
+     * stacks hold; alias type arguments, which infer only between the type arguments of two instantiations of one
+     * declaration, are such a pair.
+     */
+    invokeOnce(source, target, action, checkRecursion = true) {
         // As in tsc, a pair is visited once for each priority and variance it is inferred with.
         const mode = visitMode(this.priority, this.contravariant, this.bivariant);
         const key = visitKey(source, target);
@@ -735,19 +744,21 @@ class InferenceState {
         const caches = this.c.inferenceCaches;
         const stackDepth = this.stackDepth;
         const start = this.stackBase;
-        const end = start + stackDepth + 1;
-        setStackEntry(caches.invokeSourceStack, end - 1, source);
-        setStackEntry(caches.invokeTargetStack, end - 1, target);
-        setNumberEntry(caches.invokeModeStack, end - 1, mode);
-        setNumberEntry(caches.invokeSourceIdentities, end - 1, 0);
-        setNumberEntry(caches.invokeTargetIdentities, end - 1, 0);
-        this.stackDepth = stackDepth + 1;
-        caches.invokeStackDepth = end;
-        if (isDeeplyNestedStackEntry(this.c, caches.invokeSourceStack, caches.invokeSourceIdentities, start, end, 2))
-            this.expandingFlags |= 1 /* ExpandingFlags.Source */;
-        if (isDeeplyNestedStackEntry(this.c, caches.invokeTargetStack, caches.invokeTargetIdentities, start, end, 2))
-            this.expandingFlags |= 2 /* ExpandingFlags.Target */;
-        if (this.expandingFlags !== 3 /* ExpandingFlags.Both */) {
+        const end = start + stackDepth + (checkRecursion ? 1 : 0);
+        if (checkRecursion) {
+            setStackEntry(caches.invokeSourceStack, end - 1, source);
+            setStackEntry(caches.invokeTargetStack, end - 1, target);
+            setNumberEntry(caches.invokeModeStack, end - 1, mode);
+            setNumberEntry(caches.invokeSourceIdentities, end - 1, 0);
+            setNumberEntry(caches.invokeTargetIdentities, end - 1, 0);
+            this.stackDepth = stackDepth + 1;
+            caches.invokeStackDepth = end;
+            if (isDeeplyNestedStackEntry(this.c, caches.invokeSourceStack, caches.invokeSourceIdentities, start, end, 2))
+                this.expandingFlags |= 1 /* ExpandingFlags.Source */;
+            if (isDeeplyNestedStackEntry(this.c, caches.invokeTargetStack, caches.invokeTargetIdentities, start, end, 2))
+                this.expandingFlags |= 2 /* ExpandingFlags.Target */;
+        }
+        if (!checkRecursion || this.expandingFlags !== 3 /* ExpandingFlags.Both */) {
             switch (action) {
                 case 0 /* InferenceAction.AliasTypeArguments */:
                     this.inferFromAliasTypeArguments(source, target);
@@ -768,9 +779,11 @@ class InferenceState {
         }
         else
             this.inferencePriority = -1 /* InferencePriority.Circularity */;
-        this.stackDepth = stackDepth;
-        caches.invokeStackDepth = end - 1;
-        this.expandingFlags = saveExpandingFlags;
+        if (checkRecursion) {
+            this.stackDepth = stackDepth;
+            caches.invokeStackDepth = end - 1;
+            this.expandingFlags = saveExpandingFlags;
+        }
         this.setVisited(source, target, key, mode, this.inferencePriority);
         this.inferencePriority = Math.min(this.inferencePriority, saveInferencePriority);
     }

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

@@ -901,9 +901,9 @@ function getTargetOfImportClause(c, node) {
 function getTargetOfModuleDefault(c, moduleSymbol, node, dontResolveAlias) {
     const file = getSourceFileDeclaration(moduleSymbol);
     const specifier = getModuleSpecifierForImportOrExport(node);
-    const exportDefaultSymbol = isShorthandAmbientModuleSymbol(moduleSymbol)
-        ? undefined
-        : resolveExportByName(c, moduleSymbol, "default" /* InternalSymbolName.Default */, node, dontResolveAlias);
+    // Also when the value declaration is a shorthand ambient module (`declare module "m";`): a declaration of
+    // the same module with a body merges into the symbol and can export a default.
+    const exportDefaultSymbol = resolveExportByName(c, moduleSymbol, "default" /* InternalSymbolName.Default */, node, dontResolveAlias);
     if (specifier === undefined)
         return exportDefaultSymbol;
     let attributes;

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;
 }
 /**

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.d.ts

@@ -466,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

@@ -612,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsc-ts",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "The TypeScript 7 compiler, ported to TypeScript and compiled to a native executable.",
   "license": "Apache-2.0",
   "repository": {
@@ -40,12 +40,12 @@
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@tsc-ts/darwin-arm64": "0.1.2",
-    "@tsc-ts/darwin-x64": "0.1.2",
-    "@tsc-ts/linux-arm64-gnu": "0.1.2",
-    "@tsc-ts/linux-arm64-musl": "0.1.2",
-    "@tsc-ts/linux-x64-gnu": "0.1.2",
-    "@tsc-ts/linux-x64-musl": "0.1.2",
-    "@tsc-ts/win32-x64-msvc": "0.1.2"
+    "@tsc-ts/darwin-arm64": "0.1.4",
+    "@tsc-ts/darwin-x64": "0.1.4",
+    "@tsc-ts/linux-arm64-gnu": "0.1.4",
+    "@tsc-ts/linux-arm64-musl": "0.1.4",
+    "@tsc-ts/linux-x64-gnu": "0.1.4",
+    "@tsc-ts/linux-x64-musl": "0.1.4",
+    "@tsc-ts/win32-x64-msvc": "0.1.4"
   }
 }

package/src/compiler/checker-functions.ts

@@ -114,6 +114,7 @@ import {
 } from './checker-jsdoc.js';
 import { getEffectiveCheckNode, isFunctionLike, nodeIsMissing } from './ast-utilities.js';
 import {
+  endFlowAnalysisStop,
   getFlowTypeOfReferenceAt,
   isConstantReference,
   isReachableFlowNode,
@@ -437,6 +438,10 @@ export function checkFunctionLikeBody(c: Checker, node: Node): void {
     if (returnType !== undefined)
       checkReturnExpression(c, node, unwrapReturnType(c, returnType, functionFlags), body, body, exprType, false);
   }
+  // 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. Inferring the
+  // return type above checks the body's return expressions, which can reach the limit.
+  endFlowAnalysisStop(c, body);
 }
 
 /** Checks a generator's or async function's return type annotation. */

package/src/compiler/checker-inference.ts

@@ -853,9 +853,13 @@ class InferenceState {
     const sourceAlias = source.alias;
     const targetAlias = target.alias;
     if (sourceAlias !== undefined && targetAlias !== undefined && sourceAlias.symbol === targetAlias.symbol) {
-      // Instantiations of the same alias infer between their type arguments, once for each pair of types, as tsc does.
+      // Instantiations of the same alias infer between their type arguments, once for each pair of types, as tsc
+      // does. The pair is memoized, which keeps inference from type arguments from repeating exponentially (tsgo
+      // #64378), but it does not take part in invokeOnce's recursion-identity check: the identities of a recursive
+      // alias repeat through its properties, and below such a property that check reports a circularity and skips
+      // an inference that tsc 7.0.2 makes (#418).
       if (sourceAlias.typeArguments.length !== 0 || targetAlias.typeArguments.length !== 0)
-        this.invokeOnce(source, target, InferenceAction.AliasTypeArguments);
+        this.invokeOnce(source, target, InferenceAction.AliasTypeArguments, false);
       return;
     }
     if (source === target && (source.flags & TypeFlags.UnionOrIntersection) !== 0) {
@@ -1059,8 +1063,13 @@ class InferenceState {
     else this.inferFromTypes(source, target);
   }
 
-  /** Runs `action` once per source and target pair, stopping at circularities. */
-  invokeOnce(source: Type, target: Type, action: InferenceAction): void {
+  /**
+   * Runs `action` once per source and target pair, stopping at circularities. With `checkRecursion` false, the pair
+   * is still memoized but its action neither joins the recursion stacks nor stops at the recursion identities the
+   * stacks hold; alias type arguments, which infer only between the type arguments of two instantiations of one
+   * declaration, are such a pair.
+   */
+  invokeOnce(source: Type, target: Type, action: InferenceAction, checkRecursion = true): void {
     // As in tsc, a pair is visited once for each priority and variance it is inferred with.
     const mode = visitMode(this.priority, this.contravariant, this.bivariant);
     const key = visitKey(source, target);
@@ -1076,19 +1085,21 @@ class InferenceState {
     const caches = this.c.inferenceCaches;
     const stackDepth = this.stackDepth;
     const start = this.stackBase;
-    const end = start + stackDepth + 1;
-    setStackEntry(caches.invokeSourceStack, end - 1, source);
-    setStackEntry(caches.invokeTargetStack, end - 1, target);
-    setNumberEntry(caches.invokeModeStack, end - 1, mode);
-    setNumberEntry(caches.invokeSourceIdentities, end - 1, 0);
-    setNumberEntry(caches.invokeTargetIdentities, end - 1, 0);
-    this.stackDepth = stackDepth + 1;
-    caches.invokeStackDepth = end;
-    if (isDeeplyNestedStackEntry(this.c, caches.invokeSourceStack, caches.invokeSourceIdentities, start, end, 2))
-      this.expandingFlags |= ExpandingFlags.Source;
-    if (isDeeplyNestedStackEntry(this.c, caches.invokeTargetStack, caches.invokeTargetIdentities, start, end, 2))
-      this.expandingFlags |= ExpandingFlags.Target;
-    if (this.expandingFlags !== ExpandingFlags.Both) {
+    const end = start + stackDepth + (checkRecursion ? 1 : 0);
+    if (checkRecursion) {
+      setStackEntry(caches.invokeSourceStack, end - 1, source);
+      setStackEntry(caches.invokeTargetStack, end - 1, target);
+      setNumberEntry(caches.invokeModeStack, end - 1, mode);
+      setNumberEntry(caches.invokeSourceIdentities, end - 1, 0);
+      setNumberEntry(caches.invokeTargetIdentities, end - 1, 0);
+      this.stackDepth = stackDepth + 1;
+      caches.invokeStackDepth = end;
+      if (isDeeplyNestedStackEntry(this.c, caches.invokeSourceStack, caches.invokeSourceIdentities, start, end, 2))
+        this.expandingFlags |= ExpandingFlags.Source;
+      if (isDeeplyNestedStackEntry(this.c, caches.invokeTargetStack, caches.invokeTargetIdentities, start, end, 2))
+        this.expandingFlags |= ExpandingFlags.Target;
+    }
+    if (!checkRecursion || this.expandingFlags !== ExpandingFlags.Both) {
       switch (action) {
         case InferenceAction.AliasTypeArguments:
           this.inferFromAliasTypeArguments(source, target);
@@ -1107,9 +1118,11 @@ class InferenceState {
           break;
       }
     } else this.inferencePriority = InferencePriority.Circularity;
-    this.stackDepth = stackDepth;
-    caches.invokeStackDepth = end - 1;
-    this.expandingFlags = saveExpandingFlags;
+    if (checkRecursion) {
+      this.stackDepth = stackDepth;
+      caches.invokeStackDepth = end - 1;
+      this.expandingFlags = saveExpandingFlags;
+    }
     this.setVisited(source, target, key, mode, this.inferencePriority);
     this.inferencePriority = Math.min(this.inferencePriority, saveInferencePriority);
   }

package/src/compiler/checker-modules.ts

@@ -1331,9 +1331,9 @@ function getTargetOfModuleDefault(
 ): Symbol | undefined {
   const file = getSourceFileDeclaration(moduleSymbol);
   const specifier = getModuleSpecifierForImportOrExport(node);
-  const exportDefaultSymbol = isShorthandAmbientModuleSymbol(moduleSymbol)
-    ? undefined
-    : resolveExportByName(c, moduleSymbol, InternalSymbolName.Default, node, dontResolveAlias);
+  // Also when the value declaration is a shorthand ambient module (`declare module "m";`): a declaration of
+  // the same module with a body merges into the symbol and can export a default.
+  const exportDefaultSymbol = resolveExportByName(c, moduleSymbol, InternalSymbolName.Default, node, dontResolveAlias);
   if (specifier === undefined) return exportDefaultSymbol;
   let attributes: ImportAttributes | undefined;
   if (node.kind === SyntaxKind.ImportClause) attributes = getImportAttributes(node.parent!);

package/src/compiler/checker-narrowing.ts

@@ -369,7 +369,7 @@ export function getFlowTypeOfReferenceAt(
   flowContainer: Node | undefined,
   flowNode: FlowNode | undefined,
 ): Type {
-  if (c.flowAnalysisDisabled) return c.errorType;
+  if (c.flowAnalysisDisabled && isInFlowAnalysisStop(c, reference)) return c.errorType;
   if (flowNode === undefined) return declaredType;
   let f: FlowState;
   const stateDepth = c.flowStateDepth;
@@ -396,7 +396,7 @@ export function getFlowTypeOfReferenceAt(
     f.steps >= minFlowWalkSteps &&
     !f.incomplete &&
     !f.positional &&
-    !c.flowAnalysisDisabled &&
+    !(c.flowAnalysisDisabled && isInFlowAnalysisStop(c, reference)) &&
     c.resolutionCycleCount === cycles
   ) {
     const walk = f.walk;
@@ -438,6 +438,7 @@ function complete(f: FlowState, t: Type): Type {
 export function getTypeAtFlowNode(c: Checker, f: FlowState, start: FlowNode): Type {
   if (f.depth === 2000) {
     c.flowAnalysisDisabled = true;
+    c.flowAnalysisDisabledBody = getContainingFlowBody(f.reference);
     reportFlowControlError(c, f.reference);
     return complete(f, c.errorType);
   }
@@ -3148,9 +3149,33 @@ function getContextFreeTypeOfExpression(c: Checker, node: Node): Type {
   return t;
 }
 
-function reportFlowControlError(c: Checker, node: Node): void {
+/** The body whose walk reached the flow limit, or undefined when no body is stopped. */
+function getContainingFlowBody(node: Node): Node | undefined {
   let block: Node | undefined = 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: Checker, node: Node): boolean {
+  const stop = c.flowAnalysisDisabledBody;
+  if (stop === undefined) return false;
+  for (let n: Node | undefined = 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: Checker, body: Node): void {
+  if (c.flowAnalysisDisabledBody !== body) return;
+  c.flowAnalysisDisabled = false;
+  c.flowAnalysisDisabledBody = undefined;
+}
+
+function reportFlowControlError(c: Checker, node: Node): void {
+  const block = getContainingFlowBody(node);
   if (block === undefined) return;
   const file = getSourceFileOfNode(node);
   const span = getRangeOfTokenAtPosition(file, getStatements(block)!.pos);
@@ -3165,7 +3190,8 @@ function reportFlowControlError(c: Checker, node: Node): void {
   );
 }
 
-function isFunctionOrModuleBlock(node: Node): boolean {
+/** Whether `node` is the body of a function or a module, where flow analysis starts over (flowAnalysisDisabled). */
+export function isFunctionOrModuleBlock(node: Node): boolean {
   return (
     node.kind === SyntaxKind.SourceFile ||
     node.kind === SyntaxKind.ModuleBlock ||

package/src/compiler/checker-source-file.ts

@@ -132,6 +132,11 @@ import { checkContextualDeprecations, checkDeprecatedTypeReference } from './che
  * identifiers, which need the whole file checked first.
  */
 export function checkSourceFile(c: Checker, file: SourceFile, checkUnused = false): void {
+  // 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 & NodeCheckFlags.TypeChecked) === 0) {
     links.flags |= NodeCheckFlags.TypeChecked;
@@ -141,6 +146,9 @@ export function checkSourceFile(c: Checker, file: SourceFile, checkUnused = fals
     links.flags |= 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: Checker, file: SourceFile): void {
@@ -176,6 +184,10 @@ function checkSourceFileWorker(c: Checker, file: SourceFile): void {
  */
 export function checkSourceFileRange(c: Checker, file: SourceFile, start: number, end: number): boolean {
   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]!);
   checkDeferredNodes(c, file);
@@ -191,6 +203,9 @@ export function checkSourceFileRange(c: Checker, file: SourceFile, start: number
   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;
 }
 

package/src/compiler/checker-statements.ts

@@ -42,7 +42,7 @@ import {
   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';
@@ -57,7 +57,15 @@ import { typeToString } from './type-printer.js';
 import { TypeFacts, getNonNullableType, hasTypeFacts } from './checker-flow.js';
 
 export function checkBlock(c: Checker, node: Node): void {
-  for (const s of getStatements(node)!.nodes) checkSourceElement(c, s);
+  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: Checker, node: Node): void {

package/src/compiler/checker.ts

@@ -755,6 +755,8 @@ export class Checker implements TypeChecking {
 
   // Control flow analysis
   flowAnalysisDisabled = false;
+  /** The body whose walk reached the flow limit (flowAnalysisDisabled), until its checks finish. */
+  flowAnalysisDisabledBody: Node | undefined = undefined;
   inlineLevel = 0;
   /**
    * Shared flow nodes cached by the walks in progress, with their types: the first

package/src/compiler/parallel-check.ts

@@ -2161,7 +2161,8 @@ function checkSignals(
   }
   signals.library = library / ranges;
   signals.own = own / ranges;
-  signals.redundancy = (library - unionChars) / (library + own);
+  // Every range can be empty (all of a program's files in the shared queue), so `library + own` can be 0.
+  signals.redundancy = library + own === 0 ? 0 : (library - unionChars) / (library + own);
   signals.declarationShare = declarationFiles / files.length;
   signals.nodeModulesShare = nodeModulesFiles / files.length;
   if (config !== undefined) config.signals = signals;

package/src/compiler/run-records.ts

@@ -282,10 +282,17 @@ export function readRecord(file: string, now: number = Math.floor(Date.now() / 1
   return dropOldSamples(record, now);
 }
 
+/**
+ * A parsed value whose fields are read as `unknown` until they are checked. A native build checks a
+ * cast to a record type such as `Partial<RunRecord>` when it converts the value, and throws on a field
+ * of the wrong type, so a malformed record file would end the run instead of being ignored.
+ */
+type Unchecked<T> = { [K in keyof T]?: unknown };
+
 /** `parsed` as a record, or `undefined` where it is not one this build writes. */
 function recordOf(parsed: unknown): RunRecord | undefined {
   if (typeof parsed !== 'object' || parsed === null) return undefined;
-  const r = parsed as Partial<RunRecord>;
+  const r = parsed as Unchecked<RunRecord>;
   if (r.format !== recordFormat || typeof r.runs !== 'number' || !isShape(r.shape) || !isChoice(r.chosen))
     return undefined;
   const samples = Array.isArray(r.samples) ? r.samples.filter(isSample) : [];
@@ -304,7 +311,7 @@ function recordOf(parsed: unknown): RunRecord | undefined {
 
 function isShape(value: unknown): value is RecordShape {
   if (typeof value !== 'object' || value === null) return false;
-  const s = value as Partial<RecordShape>;
+  const s = value as Unchecked<RecordShape>;
   return (
     isNumber(s.files) &&
     isNumber(s.chars) &&
@@ -318,7 +325,7 @@ function isShape(value: unknown): value is RecordShape {
 
 function isChoice(value: unknown): value is RecordChoice {
   if (typeof value !== 'object' || value === null) return false;
-  const c = value as Partial<RecordChoice>;
+  const c = value as Unchecked<RecordChoice>;
   return (
     isNumber(c.checkers) &&
     typeof c.share === 'boolean' &&
@@ -331,7 +338,7 @@ function isChoice(value: unknown): value is RecordChoice {
 
 function isRejection(value: unknown): value is RecordRejection {
   if (typeof value !== 'object' || value === null) return false;
-  const r = value as Partial<RecordRejection>;
+  const r = value as Unchecked<RecordRejection>;
   return (
     isNumber(r.checkers) &&
     typeof r.share === 'boolean' &&
@@ -342,7 +349,7 @@ function isRejection(value: unknown): value is RecordRejection {
 
 function isSample(value: unknown): value is RecordSample {
   if (typeof value !== 'object' || value === null) return false;
-  const s = value as Partial<RecordSample>;
+  const s = value as Unchecked<RecordSample>;
   return (
     isNumber(s.run) &&
     isNumber(s.at) &&