tsc-ts 0.1.0 → 0.1.2

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. 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.
 
 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.
 
@@ -84,3 +84,9 @@ The program's diagnostics, with their text and positions, are those `tsc --api`
 An exception the compiler throws while answering a call reaches the caller as an `InternalCompilerError`, with the exception as its `cause`; the program's checker may be inconsistent after one, so dispose of the program. `program.dispose()` frees the program's checkers; calls on the program or its checker after it throw a `DisposedProgramError`.
 
 The package has a JavaScript build with declaration files for Node.js, and the TypeScript sources of the API and the compiler (the `source` export condition) for compilers that build it from source. The sources compile with scriptc: a test builds a program on `tsc-ts/api` natively and checks that it answers as the Node build.
+
+The API imports `@scriptc/threads`, an optional peer dependency that the command line doesn't use. Install it next to `tsc-ts` to use `tsc-ts/api`:
+
+```bash
+npm install -D tsc-ts @scriptc/threads
+```

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

@@ -1,4 +1,5 @@
 import type { ProgramLifetime } from '@scriptc/types';
+import { IdentifierName } from './identifier-name.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type CommentDirective, type CommentRange, type LanguageVariant, TokenFlags } from './types.js';
 import { type Diagnostic, DiagnosticFile } from './diagnostics.js';
@@ -242,8 +243,9 @@ export declare class Token extends Node {
     copy(): Token;
 }
 export declare class Identifier extends Node {
-    text: string;
-    constructor(text: string);
+    readonly identifierName: IdentifierName;
+    constructor(name: IdentifierName);
+    get text(): string;
     forEachChild(_v: NodeVisitor): boolean;
     setParentOfChildren(): void;
     deepClone(): Node;
@@ -256,7 +258,7 @@ export declare class Identifier extends Node {
  */
 export declare class ReferenceIdentifier extends Identifier {
     flowNode: FlowNode | undefined;
-    constructor(text: string);
+    constructor(name: IdentifierName);
     copy(): Identifier;
 }
 export declare class PrivateIdentifier extends Node {
@@ -2325,6 +2327,12 @@ export declare class SourceFile extends Node {
     patternAmbientModules: readonly PatternAmbientModule[];
     /** UMD exports from `export as namespace N`. */
     globalExports: SymbolTable | undefined;
+    /** 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, text: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions, statements: NodeList, endOfFileToken: Token);
     forEachChild(v: NodeVisitor): boolean;
     setParentOfChildren(): void;
@@ -2346,6 +2354,10 @@ export declare class PatternAmbientModule {
     readonly text: string;
     readonly starIndex: number;
     readonly symbol: Symbol;
+    /** The part of `text` before `starIndex`, kept so a match does not copy it. */
+    readonly prefix: string;
+    /** The part of `text` after `starIndex`, kept so a match does not copy it. */
+    readonly suffix: string;
     constructor(text: string, starIndex: number, symbol: Symbol);
     matches(candidate: string): boolean;
 }

package/dist/api/compiler/ast.js

@@ -52,9 +52,14 @@ export class NodeVisitor {
         return this.visitList(list);
     }
 }
-// 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 class Node {
     kind;
     flags;
@@ -221,10 +226,13 @@ export class Token extends Node {
     }
 }
 export class Identifier extends Node {
-    text;
-    constructor(text) {
+    identifierName;
+    constructor(name) {
         super(79 /* SyntaxKind.Identifier */);
-        this.text = text;
+        this.identifierName = name;
+    }
+    get text() {
+        return this.identifierName.text;
     }
     forEachChild(_v) {
         return false;
@@ -234,7 +242,7 @@ export class Identifier extends Node {
         return this.copy();
     }
     copy() {
-        const node = new Identifier(this.text);
+        const node = new Identifier(this.identifierName);
         node.flags = this.flags;
         node.pos = this.pos;
         node.end = this.end;
@@ -249,12 +257,12 @@ export class Identifier extends Node {
 export class ReferenceIdentifier extends Identifier {
     // Set by the binder.
     flowNode;
-    constructor(text) {
-        super(text);
+    constructor(name) {
+        super(name);
         this.flowNode = undefined;
     }
     copy() {
-        const node = new ReferenceIdentifier(this.text);
+        const node = new ReferenceIdentifier(this.identifierName);
         node.flags = this.flags;
         node.pos = this.pos;
         node.end = this.end;
@@ -6623,6 +6631,7 @@ export const emptyCommentDirectives = [];
 export const emptyPragmas = [];
 export const emptyFileReferences = [];
 export const emptyPatternAmbientModules = [];
+const emptyNumbers = [];
 /** `list` with `item` appended: a new array when `list` is empty (it may be shared), else `list` itself. */
 export function appendToList(list, item) {
     if (list.length === 0)
@@ -6695,6 +6704,13 @@ export class SourceFile extends Node {
     patternAmbientModules;
     /** UMD exports from `export as namespace N`. */
     globalExports;
+    // 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;
+    /** The nodes of this file whose grammar check needs the checker, in tree order. */
+    grammarResidualNodes;
+    /** The blocks and statements that reported a statement in an ambient context. */
+    grammarAmbientReports;
     constructor(fileName, path, text, externalModuleIndicatorOptions, statements, endOfFileToken) {
         super(308 /* SyntaxKind.SourceFile */);
         this.fileName = fileName;
@@ -6741,6 +6757,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) {
         return v.visitList(this.statements) || v.visitNode(this.endOfFileToken);
@@ -6782,17 +6801,19 @@ export class PatternAmbientModule {
     text;
     starIndex;
     symbol;
+    /** The part of `text` before `starIndex`, kept so a match does not copy it. */
+    prefix;
+    /** The part of `text` after `starIndex`, kept so a match does not copy it. */
+    suffix;
     constructor(text, starIndex, symbol) {
         this.text = text;
         this.starIndex = starIndex;
         this.symbol = symbol;
+        this.prefix = text.substring(0, starIndex);
+        this.suffix = text.substring(starIndex + 1);
     }
     matches(candidate) {
-        const text = this.text;
-        const star = this.starIndex;
-        return (candidate.length >= text.length - 1 &&
-            candidate.startsWith(text.substring(0, star)) &&
-            candidate.endsWith(text.substring(star + 1)));
+        return (candidate.length >= this.text.length - 1 && candidate.startsWith(this.prefix) && candidate.endsWith(this.suffix));
     }
 }
 function containsNonASCII(text) {

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

@@ -28,6 +28,7 @@ import { checkFunctionOrConstructorSymbol, checkFunctionOrMethodSymbols } from '
 import { checkClassHeritage, checkClassOrInterfaceForDuplicateIndexSignatures, checkInterfaceHeritage, } from './checker-heritage.js';
 import { checkDecorators, getFirstTransformableStaticClassElement } from './checker-decorators.js';
 import { getTypeOfNode } from './checker-services.js';
+import { IdentifierName } from './identifier-name.js';
 export function checkClassDeclaration(c, node) {
     checkClassLikeDeclaration(c, node);
     checkClassMembers(c, node);
@@ -464,7 +465,7 @@ function newThisPropertyReference(symbol, container, flowNode) {
     if (name.startsWith('\ufffe#'))
         accessName = new PrivateIdentifier(name.substring(name.indexOf('@') + 1));
     else
-        accessName = new Identifier(name);
+        accessName = new Identifier(new IdentifierName(name));
     const thisExpression = new KeywordExpression(109 /* SyntaxKind.ThisKeyword */);
     const reference = new PropertyAccessExpression(thisExpression, undefined, accessName, 0 /* NodeFlags.None */);
     thisExpression.parent = reference;

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

@@ -18,6 +18,26 @@ export declare function pushCachedContextualType(c: Checker, node: Node): void;
 export declare function popContextualType(c: Checker): void;
 /** The index of the contextual type pushed onto `node`, or -1. */
 export declare function findContextualNode(c: Checker, node: Node, includeCaches: boolean): number;
+/**
+ * The id of the contextual type in force for `node`, or -1 if the node's contextual type is not on
+ * the stack. A key built from -1 can't tell a check under a contextual type that was not pushed from
+ * a check with no contextual type, so callers record nothing under -1.
+ */
+export declare function getContextualTypeId(c: Checker, node: Node): number;
+/**
+ * Whether a check of `node` has no contextual type and no inference context, so its type is a
+ * function of the node and the check mode alone: the node is not on the contextual stack, no
+ * inference context contains it, and its parent gives it no contextual type. The parents answered
+ * here are the ones `getContextualTypeEx` returns `undefined` for without computing anything; a
+ * parent it computes a type for is not answered, so the result is never "yes" for a check that
+ * could have a contextual type.
+ *
+ * Types computed inside a flow loop are provisional (the checker does not cache them either), so a
+ * check in a loop is not context-free. The same holds while a reduce label is in force, as when
+ * flow analysis revisits a `finally` block with the antecedents of one outgoing path: the flow
+ * state differs from the one the earlier check of the block saw.
+ */
+export declare function isCheckedWithoutContextualType(c: Checker, node: Node): boolean;
 export declare function pushInferenceContext(c: Checker, node: Node, context: InferenceContext | undefined): void;
 export declare function popInferenceContext(c: Checker): void;
 /** The inference context of the innermost call argument containing `node`. */

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

@@ -1,6 +1,6 @@
 // Contextual typing: the type an expression's position implies, and contextual signatures.
 import { resolvedReturnTypeOf } from './side-state.js';
-import { getInitializer, getName, getParameters, getType, getText, getSymbol, getTypeParameters, JsxAttribute, JsxElement, } from './ast.js';
+import { getArguments, getInitializer, getName, getParameters, getType, getText, getSymbol, getTypeParameters, JsxAttribute, JsxElement, } from './ast.js';
 import { getImmediatelyInvokedFunctionExpression, isFunctionExpressionOrArrowFunction, isObjectLiteralMethod, isStatic, } from './binder-utilities.js';
 import { filterType, getIntersectionType, getNumberLiteralType, getRegularTypeOfLiteralType, getUnionType, getUnionTypeEx, getWidenedLiteralType, getEndElementCount, getStringLiteralType, getTypeArguments, getTypeReferenceArity, mapType, mapTypeEx, isTupleType, tupleTargetOf, typesOf, } from './checker-type-factory.js';
 import { combineUnionOrIntersectionMemberSignatures, compareTypeParametersIdentical, findApplicableIndexInfo, getApparentType, getBaseConstraintOrType, getIndexInfosOfStructuredType, getPropertiesOfType, getPropertyOfType, getReducedType, getSignaturesOfType, } from './checker-members.js';
@@ -68,6 +68,116 @@ export function findContextualNode(c, node, includeCaches) {
             return i;
     return -1;
 }
+/**
+ * The id of the contextual type in force for `node`, or -1 if the node's contextual type is not on
+ * the stack. A key built from -1 can't tell a check under a contextual type that was not pushed from
+ * a check with no contextual type, so callers record nothing under -1.
+ */
+export function getContextualTypeId(c, node) {
+    const index = findContextualNode(c, node, true);
+    if (index < 0)
+        return -1;
+    const t = c.inferenceCaches.contextualTypes[index];
+    return t === undefined ? -1 : t.id;
+}
+/**
+ * Whether a check of `node` has no contextual type and no inference context, so its type is a
+ * function of the node and the check mode alone: the node is not on the contextual stack, no
+ * inference context contains it, and its parent gives it no contextual type. The parents answered
+ * here are the ones `getContextualTypeEx` returns `undefined` for without computing anything; a
+ * parent it computes a type for is not answered, so the result is never "yes" for a check that
+ * could have a contextual type.
+ *
+ * Types computed inside a flow loop are provisional (the checker does not cache them either), so a
+ * check in a loop is not context-free. The same holds while a reduce label is in force, as when
+ * flow analysis revisits a `finally` block with the antecedents of one outgoing path: the flow
+ * state differs from the one the earlier check of the block saw.
+ */
+export function isCheckedWithoutContextualType(c, node) {
+    if (c.flowLoopStack.length !== 0)
+        return false;
+    if (c.flowReduceLabels.length !== 0)
+        return false;
+    if (findContextualNode(c, node, true) >= 0)
+        return false;
+    if (getInferenceContext(c, node) !== undefined)
+        return false;
+    const parent = node.parent;
+    if (parent === undefined)
+        return true;
+    switch (parent.kind) {
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 210 /* SyntaxKind.BindingElement */:
+            // Only the initializer is contextually typed by the declaration.
+            return getInitializer(parent) !== node;
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */: {
+            // Only the arguments are contextually typed by the parameters; the callee is not.
+            const args = getArguments(parent);
+            if (args !== undefined) {
+                for (const arg of args.nodes)
+                    if (arg === node)
+                        return false;
+            }
+            return true;
+        }
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+            // Only a method takes the property's contextual type.
+            return node.kind !== 176 /* SyntaxKind.MethodDeclaration */;
+        case 228 /* SyntaxKind.BinaryExpression */: {
+            const binary = parent;
+            if (binary.type !== undefined)
+                return false;
+            switch (binary.operatorToken.kind) {
+                case 63 /* SyntaxKind.EqualsToken */:
+                case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+                case 75 /* SyntaxKind.BarBarEqualsToken */:
+                case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+                    return node !== binary.right;
+                case 56 /* SyntaxKind.BarBarToken */:
+                case 60 /* SyntaxKind.QuestionQuestionToken */:
+                case 55 /* SyntaxKind.AmpersandAmpersandToken */:
+                case 27 /* SyntaxKind.CommaToken */:
+                    return false;
+            }
+            return true;
+        }
+        case 229 /* SyntaxKind.ConditionalExpression */: {
+            const conditional = parent;
+            return node !== conditional.whenTrue && node !== conditional.whenFalse;
+        }
+        case 241 /* SyntaxKind.TemplateSpan */: {
+            // Only a tagged template types its spans.
+            const template = parent.parent;
+            return template.parent === undefined || template.parent.kind !== 217 /* SyntaxKind.TaggedTemplateExpression */;
+        }
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 255 /* SyntaxKind.ReturnStatement */:
+        case 231 /* SyntaxKind.YieldExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
+        case 172 /* SyntaxKind.Decorator */:
+        case 236 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 306 /* SyntaxKind.SpreadAssignment */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 296 /* SyntaxKind.JsxExpression */:
+        case 293 /* SyntaxKind.JsxAttribute */:
+        case 295 /* SyntaxKind.JsxSpreadAttribute */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+            return false;
+    }
+    return true;
+}
 export function pushInferenceContext(c, node, context) {
     const caches = c.inferenceCaches;
     const depth = caches.inferenceDepth;

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

@@ -43,7 +43,7 @@ import { isFunctionLike, isImportCall, isInJSFile, isRequireCall } from './ast-u
 import { isLiteralKind } from './printer/utilities.js';
 import { convertAutoToAny, isEvolvingArrayOperationTarget, getAssignmentTargetKind, getControlFlowContainer, isConstantVariable, isInCompoundLikeAssignment, isMutableLocalVariableDeclaration, isParameterOrMutableLocalVariable, isPastLastAssignment, isSymbolAssignedDefinitely, getFlowTypeOfReference, getNarrowedTypeOfSymbol, } from './checker-narrowing.js';
 import { getFlowTypeOfAutoTypedProperty, getThisTypeOfAssignedFunction } from './checker-javascript.js';
-import { checkExpressionWithContextualType, getThisTypeOfObjectLiteralMember } from './checker-contextual.js';
+import { checkExpressionWithContextualType, getThisTypeOfObjectLiteralMember, isCheckedWithoutContextualType, } from './checker-contextual.js';
 import { getInferenceContext, instantiateContextualType, popContextualType, pushCachedContextualType, } from './checker-contextual.js';
 import { addIntraExpressionInferenceSite, isConstTypeVariable } from './checker-inference.js';
 import { isContextSensitiveFunctionOrObjectLiteralMethod } from './checker-contextual.js';
@@ -56,6 +56,17 @@ export function checkExpression(c, node) {
     return checkExpressionEx(c, node, 0 /* CheckMode.Normal */);
 }
 export function checkExpressionEx(c, node, checkMode) {
+    // A completed check of this node under this mode answers this one when the check has no
+    // contextual type and no inference context: the checker's state only grew since, so this check
+    // would produce the type the completed one produced, report the diagnostics it reported and
+    // defer the nodes it deferred. Those diagnostics are equal to ones already reported and a node
+    // is deferred at most once, so serving the completed type changes neither.
+    const recordable = isCheckedWithoutContextualType(c, node);
+    if (recordable) {
+        const recorded = c.exprCheckRecord.get(node.id, checkMode);
+        if (recorded !== undefined)
+            return recorded;
+    }
     const saveCurrentNode = c.currentNode;
     c.currentNode = node;
     c.instantiationCount = 0;
@@ -63,6 +74,8 @@ export function checkExpressionEx(c, node, checkMode) {
     if (isConstEnumObjectTypeLocal(t))
         checkConstEnumAccess(c, node, t);
     c.currentNode = saveCurrentNode;
+    if (recordable)
+        c.exprCheckRecord.set(node.id, checkMode, t);
     return t;
 }
 /**

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

@@ -1,10 +1,17 @@
 import { type Node, type NodeList, NodeVisitor, type ObjectLiteralExpression, type SourceFile } from './ast.js';
 import { type Checker } from './checker.js';
-import { ModuleKind } from './options.js';
+import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+import { type CompilerOptions, ModuleKind } from './options.js';
 import { SourceFileMetadata } from './program-utilities.js';
 import { Scanner } from './scanner.js';
 /** Runs the grammar checks of every node of `file`. */
 export declare function checkGrammarSourceFile(c: Checker, file: SourceFile): void;
+/**
+ * Runs the grammar checks of `file` in a parse thread, before the file is published: the checks that
+ * don't need the checker report now, and the nodes of those that do are kept for the checker, which
+ * runs them in the same tree order (`checkGrammarSourceFile`).
+ */
+export declare function checkGrammarSourceFileInParseThread(file: SourceFile, options: CompilerOptions, metadata: SourceFileMetadata): void;
 /** Checks the grammar of an object literal each time it is checked, as tsgo does. */
 export declare function checkGrammarObjectLiteralOfExpression(c: Checker, node: ObjectLiteralExpression, inDestructuring: boolean): void;
 /** Reports a trailing comma after the rest element of a destructuring assignment. */
@@ -17,7 +24,10 @@ export declare function checkGrammarAwaitExpression(c: Checker, node: Node): voi
 export declare function checkGrammarYieldOfExpression(c: Checker, node: Node): void;
 /** Per-file state of the grammar walk. */
 export declare class GrammarChecker extends NodeVisitor {
-    readonly c: Checker;
+    /** The checker of a walk in the checker thread; undefined for a walk in a parse thread. */
+    readonly c: Checker | undefined;
+    readonly compilerOptions: CompilerOptions;
+    readonly languageVersion: number;
     readonly file: SourceFile;
     /** Grammar errors are only reported in files without parse errors. */
     readonly hasParseErrors: boolean;
@@ -25,10 +35,35 @@ export declare class GrammarChecker extends NodeVisitor {
     readonly metadata: SourceFileMetadata;
     readonly legacyDecorators: boolean;
     /** Blocks and statements that already reported a statement in an ambient context. */
-    readonly reportedAmbientStatements: Set<number>;
+    reportedAmbientStatements: Set<number>;
+    /**
+     * The IDs `reportedAmbientStatements` gained in a parse thread's walk, in the order it gained them, so
+     * that the reports of a node whose check the checker runs are undone without copying the set.
+     * Undefined in the checker thread, where no check is undone.
+     */
+    private readonly ambientReportLog;
+    /**
+     * The diagnostics of a walk in a parse thread, which has no checker, for the checker to add to its
+     * collection; undefined in the checker thread, where they are reported as they are found.
+     */
+    readonly diagnostics: Diagnostic[] | undefined;
+    /** The nodes of a parse thread's walk whose check needs the checker, in tree order. */
+    readonly residualNodes: Node[] | undefined;
+    /** Set when the check of a parse thread's walk needs the checker: the checker runs that node. */
+    needsChecker: boolean;
     private scanner;
-    constructor(c: Checker, file: SourceFile);
+    constructor(c: Checker | undefined, file: SourceFile, options?: CompilerOptions, metadata?: SourceFileMetadata, 
+    /** `file.grammarAmbientReports`: what a parse thread's walk already reported. */
+    ambientReports?: readonly number[]);
     visitNode(node: Node): boolean;
+    /** Records that `id` reported a statement in an ambient context. */
+    reportAmbientStatement(id: number): void;
+    /** Undoes the ambient-context reports added since the log had `mark` entries. */
+    private undoAmbientReports;
+    /** Reports an error at `node`, as `Checker.error`; returns the diagnostic. */
+    error(node: Node | undefined, message: DiagnosticMessage, ...args: string[]): Diagnostic;
+    /** Reports `diagnostic`, as `Checker.addDiagnostic`. */
+    report(diagnostic: Diagnostic): void;
     /** A scanner over the file's text, for rescanning tokens. */
     getScanner(): Scanner;
 }