tsc-ts 0.0.9 → 0.0.10

package/README.md

@@ -31,7 +31,7 @@ npx tsc-ts -p tsconfig.json
 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`.
+`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`, 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.
 

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

@@ -2281,6 +2281,8 @@ export declare class SourceFile extends Node {
     identifierCount: number;
     nodeCount: number;
     textCount: number;
+    /** The API's binary encoding of this file, when an API server keeps it (`keptEncodingOf`). */
+    apiEncoding: Uint8Array | undefined;
     /** Module specifiers of imports, exports, `require` calls and `import()` types, in source order. */
     imports: Node[];
     /** Names of `declare module "x"` augmentations and `declare global` blocks in modules. */

package/dist/api/compiler/ast.js

@@ -6641,6 +6641,8 @@ export class SourceFile extends Node {
     identifierCount;
     nodeCount;
     textCount;
+    /** The API's binary encoding of this file, when an API server keeps it (`keptEncodingOf`). */
+    apiEncoding;
     /** Module specifiers of imports, exports, `require` calls and `import()` types, in source order. */
     imports;
     /** Names of `declare module "x"` augmentations and `declare global` blocks in modules. */
@@ -6699,6 +6701,7 @@ export class SourceFile extends Node {
         this.identifierCount = 0;
         this.nodeCount = 0;
         this.textCount = 0;
+        this.apiEncoding = undefined;
         this.imports = [];
         this.moduleAugmentations = emptyNodes;
         this.ambientModuleNames = emptyStrings;

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

@@ -709,7 +709,11 @@ export function reorderCandidates(c, signatures, callChainFlags) {
             spliceIndex = index;
         if (callChainFlags !== 0)
             signature = getOptionalCallSignature(c, signature, callChainFlags);
-        result.splice(spliceIndex, 0, signature);
+        // Most signatures go at the end, where a push is cheaper than an inserting splice.
+        if (spliceIndex === result.length)
+            result.push(signature);
+        else
+            result.splice(spliceIndex, 0, signature);
     }
     return result;
 }

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

@@ -2255,7 +2255,8 @@ function getEmitSyntaxOfImportOrExport(g) {
     return ModuleKind.None;
 }
 function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
-    const seen = new Map();
+    // An object literal with one property can't repeat a name, so it needs no table of names.
+    const seen = node.properties.nodes.length > 1 ? new Map() : undefined;
     for (const property of node.properties.nodes) {
         if (property.kind === 305 /* SyntaxKind.SpreadAssignment */) {
             if (inDestructuring) {
@@ -2313,7 +2314,7 @@ function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
         if (inDestructuring)
             continue;
         const effectiveName = getEffectivePropertyNameForPropertyNameNode(g.c, name);
-        if (effectiveName === undefined)
+        if (effectiveName === undefined || seen === undefined)
             continue;
         const existingKind = seen.get(effectiveName);
         if (existingKind === undefined) {

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

@@ -450,8 +450,14 @@ class InferenceState {
                         index = 0;
                         while (index < inference.candidateDepths.length && inference.candidateDepths[index] >= this.depth)
                             index++;
-                        inference.candidates.splice(index, 0, candidate);
-                        inference.candidateDepths.splice(index, 0, this.depth);
+                        if (index === inference.candidates.length) {
+                            inference.candidates.push(candidate);
+                            inference.candidateDepths.push(this.depth);
+                        }
+                        else {
+                            inference.candidates.splice(index, 0, candidate);
+                            inference.candidateDepths.splice(index, 0, this.depth);
+                        }
                         clearCachedInferences(this.inferences);
                     }
                 }

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

@@ -1268,7 +1268,8 @@ export function getPropertyOfTypeEx(c, t, name, skipObjectFunctionPropertyAugmen
     if (!isOwnReducedApparentType(t))
         t = getReducedApparentTypeWorker(c, t);
     if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
-        const resolved = resolveStructuredTypeMembers(c, t);
+        // The first test of resolveStructuredTypeMembers, here where most lookups find the members resolved.
+        const resolved = (t.objectFlags & 2097152 /* ObjectFlags.MembersResolved */) !== 0 ? t : resolveStructuredTypeMembers(c, t);
         const symbol = getResolvedMember(resolved, name);
         if (symbol !== undefined && includeTypeOnlyMembers)
             return symbol;

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

@@ -989,7 +989,10 @@ export function insertType(c, types, t) {
     const index = binarySearchTypes(c, types, t);
     if (index >= 0)
         return false;
-    types.splice(~index, 0, t);
+    if (~index === types.length)
+        types.push(t);
+    else
+        types.splice(~index, 0, t);
     return true;
 }
 // ---- Iterating unions
@@ -1198,7 +1201,10 @@ function insertTypeNearLast(c, set, t) {
         else
             high = middle - 1;
     }
-    types.splice(low, 0, t);
+    if (low === types.length)
+        types.push(t);
+    else
+        types.splice(low, 0, t);
     set.last = low;
 }
 function getUnionTypeWorker(c, types, unionReduction, alias, origin) {

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

@@ -71,6 +71,10 @@ declare class DiagnosticCollection {
     /** An already reported diagnostic equal to `diagnostic`, if any. */
     lookup(diagnostic: Diagnostic): Diagnostic | undefined;
     globals(): Diagnostic[];
+    /** The global diagnostics `withoutNewGlobals` removed. */
+    removedGlobals: number;
+    /** Runs `run`, then removes the global diagnostics it added. */
+    withoutNewGlobals<T>(run: () => T): T;
     /** Records the diagnostics added from now on. */
     startLog(): void;
     /** The diagnostics added since `startLog`, in order; stops recording. */
@@ -491,6 +495,13 @@ export declare class Checker implements TypeChecking {
     getSuggestionDiagnostics(file: SourceFile): Diagnostic[];
     /** Diagnostics without a file, such as missing global types. */
     getGlobalDiagnostics(): Diagnostic[];
+    /**
+     * Runs `run` (such as emitting declarations), then forgets the global diagnostics it reported:
+     * the program collects global diagnostics before it emits.
+     */
+    withoutGlobalDiagnostics<T>(run: () => T): T;
+    /** The global diagnostics `withoutGlobalDiagnostics` forgot so far. */
+    forgottenGlobalDiagnostics(): number;
     /** The rarely used links of `symbol`, created on first use. */
     symbolLinks(symbol: Symbol): SymbolLinks;
     /** The links of `symbol` if it has any, without creating them. */

package/dist/api/compiler/checker.js

@@ -137,6 +137,35 @@ class DiagnosticCollection {
         }
         return this.global.slice();
     }
+    /** The global diagnostics `withoutNewGlobals` removed. */
+    removedGlobals = 0;
+    /** Runs `run`, then removes the global diagnostics it added. */
+    withoutNewGlobals(run) {
+        const outer = this.log;
+        const added = [];
+        this.log = added;
+        try {
+            return run();
+        }
+        finally {
+            this.log = outer;
+            if (outer !== undefined)
+                for (const d of added)
+                    outer.push(d);
+            const globals = new Set();
+            for (const d of added)
+                if (d.file === undefined)
+                    globals.add(d);
+            if (globals.size > 0) {
+                this.removedGlobals += globals.size;
+                let kept = 0;
+                for (const d of this.global)
+                    if (!globals.has(d))
+                        this.global[kept++] = d;
+                this.global.length = kept;
+            }
+        }
+    }
     /** Records the diagnostics added from now on. */
     startLog() {
         this.log = [];
@@ -780,6 +809,17 @@ export class Checker {
     getGlobalDiagnostics() {
         return this.diagnostics.globals();
     }
+    /**
+     * Runs `run` (such as emitting declarations), then forgets the global diagnostics it reported:
+     * the program collects global diagnostics before it emits.
+     */
+    withoutGlobalDiagnostics(run) {
+        return this.diagnostics.withoutNewGlobals(run);
+    }
+    /** The global diagnostics `withoutGlobalDiagnostics` forgot so far. */
+    forgottenGlobalDiagnostics() {
+        return this.diagnostics.removedGlobals;
+    }
     // ---- Links
     /** The rarely used links of `symbol`, created on first use. */
     symbolLinks(symbol) {

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

@@ -61,6 +61,28 @@ export declare class EmitIndexes {
     readonly declarations: DeclarationGlobals | undefined;
     constructor(program: Program);
 }
+/**
+ * The JavaScript emit of a program's files without a checker, for emit threads (parallel-emit.ts).
+ * JavaScript emit asks the checker only how decorator metadata serializes a type
+ * (`CheckerEmitResolver`): with `kinds`, the answers the main thread's checker gave
+ * (`recordMetadataKinds`), else files with decorator metadata are emitted by a `ProgramEmitter`.
+ */
+export declare class JavaScriptEmitter {
+    private readonly host;
+    private readonly recorded;
+    constructor(program: Program, kinds?: readonly number[]);
+    /**
+     * Emits `file`, or returns undefined if its decorator metadata asked for a kind that wasn't recorded: what
+     * was written is then not the file's emit, and it must be emitted with the checker.
+     */
+    emit(file: SourceFile, writer: OutputWriter): EmitResult | undefined;
+}
+/**
+ * The serialization kinds of decorator metadata that the checker of `checked` gives the type references of
+ * `files`, in the order JavaScript emit asks for them: the type name's node id, the location's node id (-1 for
+ * none) and the kind, for each. Only the decorator metadata transform runs, as the first transform of emit.
+ */
+export declare function recordMetadataKinds(checked: CheckedProgram, files: readonly SourceFile[]): number[];
 /** A checked program and the emit of its files. */
 export declare class ProgramEmitter {
     readonly checked: CheckedProgram;
@@ -110,9 +132,11 @@ export declare class PlainProgram extends CompilerProgram {
 export declare function handleNoEmitOnError(program: CompilerProgram): EmitResult | undefined;
 /**
  * Config and syntax errors; without syntax errors, program, global and semantic errors too, and
- * declaration errors under `noEmit` (or `withDeclarationDiagnostics`).
+ * declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With `declarationsLater`, the
+ * declaration errors are left to `program.emit`, which reports them under `noEmit` (without
+ * `noEmitOnError`) whether or not other errors were found.
  */
-export declare function getDiagnosticsOfProgram(program: CompilerProgram, withDeclarationDiagnostics: boolean): Diagnostic[];
+export declare function getDiagnosticsOfProgram(program: CompilerProgram, withDeclarationDiagnostics: boolean, declarationsLater?: boolean): Diagnostic[];
 /** Combines emit results in order. */
 export declare function combineEmitResults(results: readonly EmitResult[]): EmitResult;
 export { CheckedProgram };

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

@@ -6,6 +6,10 @@ import { CheckerDeclarationEmitResolver, CheckerEmitResolver } from './checker-e
 import { getEmitModuleFormatOfFile } from './program-utilities.js';
 import { DeclarationGlobals, SyntacticDeclarationEmitResolver } from './transformers/declarations-syntactic.js';
 import { mark } from './timeline.js';
+import { DecoratorMetadata } from './transformers/decorator-metadata.js';
+import { SyntaxFacts } from './transformers/syntax-facts.js';
+import { EmitContext } from './printer/emit-context.js';
+import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
 import { ModuleFormatHost } from './transformers/module.js';
 import { ModuleLookup, ReferenceResolver } from './transformers/reference-resolver.js';
 /** Where emit writes files. */
@@ -165,6 +169,82 @@ export class EmitIndexes {
             : undefined;
     }
 }
+/**
+ * The JavaScript emit of a program's files without a checker, for emit threads (parallel-emit.ts).
+ * JavaScript emit asks the checker only how decorator metadata serializes a type
+ * (`CheckerEmitResolver`): with `kinds`, the answers the main thread's checker gave
+ * (`recordMetadataKinds`), else files with decorator metadata are emitted by a `ProgramEmitter`.
+ */
+export class JavaScriptEmitter {
+    host;
+    recorded;
+    constructor(program, kinds = []) {
+        const options = program.options;
+        const indexes = program.emitIndexes;
+        const references = new ReferenceResolver(options, program.getSourceFiles(), new ProgramModules(program), indexes !== undefined ? indexes.globals : undefined);
+        this.recorded = kinds.length > 0 ? new RecordedKindsEmitResolver(options, references, kinds) : undefined;
+        this.host = new ProgramEmitHost(program, this.recorded ?? new SyntacticEmitResolver(options, references));
+    }
+    /**
+     * Emits `file`, or returns undefined if its decorator metadata asked for a kind that wasn't recorded: what
+     * was written is then not the file's emit, and it must be emitted with the checker.
+     */
+    emit(file, writer) {
+        const host = this.host;
+        const recorded = this.recorded;
+        if (recorded !== undefined)
+            recorded.missed = false;
+        host.writer = writer;
+        const result = emitFiles(host, [file], 1 /* EmitOnly.Js */);
+        host.writer = undefined;
+        return recorded !== undefined && recorded.missed ? undefined : result;
+    }
+}
+/**
+ * The serialization kinds of decorator metadata that the checker of `checked` gives the type references of
+ * `files`, in the order JavaScript emit asks for them: the type name's node id, the location's node id (-1 for
+ * none) and the kind, for each. Only the decorator metadata transform runs, as the first transform of emit.
+ */
+export function recordMetadataKinds(checked, files) {
+    const program = checked.program;
+    const options = program.options;
+    const indexes = program.emitIndexes;
+    const references = new ReferenceResolver(options, program.getSourceFiles(), new ProgramModules(program), indexes !== undefined ? indexes.globals : undefined);
+    const resolver = new RecordingEmitResolver(options, references, checked.checker);
+    for (const file of files)
+        new DecoratorMetadata(new EmitContext(), options, resolver, new SyntaxFacts()).transformSourceFile(file);
+    return resolver.kinds;
+}
+/** A `CheckerEmitResolver` that records the serialization kinds it gives (`recordMetadataKinds`). */
+class RecordingEmitResolver extends CheckerEmitResolver {
+    kinds = [];
+    getTypeReferenceSerializationKind(typeName, location) {
+        const kind = super.getTypeReferenceSerializationKind(typeName, location);
+        this.kinds.push(typeName.id, location === undefined ? -1 : location.id, kind);
+        return kind;
+    }
+}
+/** Answers serialization kinds from those recorded on the main thread; `missed` once one wasn't. */
+class RecordedKindsEmitResolver extends SyntacticEmitResolver {
+    kinds;
+    /** The kind and location of each type name, by the type name's node id. */
+    byName = new Map();
+    missed = false;
+    constructor(options, referenceResolver, kinds) {
+        super(options, referenceResolver);
+        this.kinds = kinds;
+        for (let i = 0; i < kinds.length; i += 3)
+            if (!this.byName.has(kinds[i]))
+                this.byName.set(kinds[i], i);
+    }
+    getTypeReferenceSerializationKind(typeName, location) {
+        const at = this.byName.get(typeName.id);
+        if (at !== undefined && this.kinds[at + 1] === (location === undefined ? -1 : location.id))
+            return this.kinds[at + 2];
+        this.missed = true;
+        return super.getTypeReferenceSerializationKind(typeName, location);
+    }
+}
 /** A checked program and the emit of its files. */
 export class ProgramEmitter {
     checked;
@@ -291,14 +371,24 @@ export class PlainProgram extends CompilerProgram {
         const program = this.program;
         const files = program.getSourceFiles();
         const parallel = this.checked.emittedInParallel;
-        // Checker threads emitted the files they checked (parallel-check.ts); the others are emitted here, in order.
+        // Checker threads emitted the files they checked (parallel-check.ts), or emit threads their JavaScript
+        // (parallel-emit.ts); the rest is emitted here, in order.
         const result = parallel === undefined
             ? this.emitter.emit(files, 0 /* EmitOnly.All */, writer)
             : combineEmitResults(files.map((file, i) => {
                 const emitted = parallel[i];
-                return emitted !== undefined
-                    ? writeHeldOutputs(emitted, writer)
-                    : this.emitter.emit([file], 0 /* EmitOnly.All */, writer);
+                // The declaration thread emitted the declarations of the files it could (parallel-emit.ts).
+                const ahead = this.checked.declarationsEmittedAhead;
+                const declarations = () => ahead?.[i] ?? this.emitter.emit([file], 2 /* EmitOnly.Dts */, writer);
+                if (emitted === undefined)
+                    return ahead !== undefined
+                        ? combineEmitResults([this.emitter.emit([file], 1 /* EmitOnly.Js */, writer), declarations()])
+                        : this.emitter.emit([file], 0 /* EmitOnly.All */, writer);
+                const written = writeHeldOutputs(emitted, writer);
+                // Emit threads emit JavaScript only.
+                if (!this.checked.javaScriptEmittedOnThreads || !getEmitDeclarations(options))
+                    return written;
+                return combineEmitResults([written, declarations()]);
             }));
         if (options.noEmit === true) {
             // Emit is skipped only for files that would have been emitted.
@@ -326,9 +416,11 @@ export function handleNoEmitOnError(program) {
 }
 /**
  * Config and syntax errors; without syntax errors, program, global and semantic errors too, and
- * declaration errors under `noEmit` (or `withDeclarationDiagnostics`).
+ * declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With `declarationsLater`, the
+ * declaration errors are left to `program.emit`, which reports them under `noEmit` (without
+ * `noEmitOnError`) whether or not other errors were found.
  */
-export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics) {
+export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics, declarationsLater = false) {
     const result = [...program.getConfigFileParsingDiagnostics()];
     const configCount = result.length;
     for (const d of program.getSyntacticDiagnostics())
@@ -356,7 +448,8 @@ export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics) {
             result.push(d);
         mark('semantic diagnostics');
     }
-    if ((withDeclarationDiagnostics || options.noEmit === true) &&
+    if (!declarationsLater &&
+        (withDeclarationDiagnostics || options.noEmit === true) &&
         getEmitDeclarations(options) &&
         result.length === configCount) {
         for (const d of program.getDeclarationDiagnostics())

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

@@ -109,6 +109,11 @@ export declare class Diagnostic {
     readonly reportsDeprecated: boolean;
     skippedOnNoEmit: boolean;
     repopulateInfo: RepopulateInfo | undefined;
+    /**
+     * What `formatDiagnostic` gives for this diagnostic in `formattedReports.format`, where the checker
+     * thread that found it formatted it (`packResult`); `''` otherwise.
+     */
+    formatted: string;
     constructor(file: DiagnosticFile | undefined, pos: number, end: number, message: DiagnosticMessage, args?: readonly string[]);
     localize(locale: Locale): string;
     addMessageChain(chain: Diagnostic | undefined): Diagnostic;
@@ -132,6 +137,14 @@ export declare function chainDiagnostic(chain: Diagnostic | undefined, message:
 export declare function compareCodePoints(a: string, b: string): number;
 /** The order tsc reports diagnostics in: by file, position, code, arguments, then elaboration. */
 export declare function compareDiagnostics(a: Diagnostic, b: Diagnostic): number;
+/**
+ * `diagnostics` in the order of `compareDiagnostics`, equal ones in their order in `diagnostics`. File
+ * names are compared once per pair of files rather than once per pair of diagnostics: the distinct
+ * files are sorted by name, and each diagnostic sorts by its file's place in that order, then by the
+ * rest of `compareDiagnostics`. A program's diagnostics come a file at a time, so the files are found
+ * from the runs of one file.
+ */
+export declare function sortDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[];
 /** Whether two diagnostics report the same thing, ignoring related information. */
 export declare function equalDiagnosticsNoRelatedInfo(a: Diagnostic, b: Diagnostic): boolean;
 export declare function equalDiagnostics(a: Diagnostic, b: Diagnostic): boolean;
@@ -145,6 +158,15 @@ export interface DiagnosticFormatOptions {
 export declare function flattenDiagnosticMessage(diagnostic: Diagnostic, newLine: string, locale: Locale): string;
 /** `file(line,col): error TS1005: message`, as tsc prints without `--pretty`. */
 export declare function formatDiagnostic(diagnostic: Diagnostic, options: DiagnosticFormatOptions): string;
+/**
+ * The plain format the main thread reports a compilation's diagnostics in (`DiagnosticReporter.plainFormat`),
+ * which its checker threads receive a copy of and format the diagnostics they send back in
+ * (`Diagnostic.formatted`). Unset where diagnostics are reported with color and context, or not at all.
+ */
+export declare class FormattedReports {
+    format: DiagnosticFormatOptions | undefined;
+}
+export declare const formattedReports: FormattedReports;
 /** `formatDiagnostic` of each diagnostic. */
 export declare function formatDiagnostics(diagnostics: readonly Diagnostic[], options: DiagnosticFormatOptions): string;
 /** The colored form with source snippets, as tsc prints with `--pretty`. */

package/dist/api/compiler/diagnostics.js

@@ -326,6 +326,11 @@ export class Diagnostic {
     reportsDeprecated;
     skippedOnNoEmit = false;
     repopulateInfo = undefined;
+    /**
+     * What `formatDiagnostic` gives for this diagnostic in `formattedReports.format`, where the checker
+     * thread that found it formatted it (`packResult`); `''` otherwise.
+     */
+    formatted = '';
     constructor(file, pos, end, message, args = []) {
         this.file = file;
         this.pos = pos;
@@ -358,6 +363,7 @@ export class Diagnostic {
         result.relatedInformation = this.relatedInformation;
         result.skippedOnNoEmit = this.skippedOnNoEmit;
         result.repopulateInfo = this.repopulateInfo;
+        result.formatted = this.formatted;
         return result;
     }
 }
@@ -463,10 +469,12 @@ function compareRelatedInfo(a, b) {
 export function compareDiagnostics(a, b) {
     if (a === b)
         return 0;
-    let c = compareCodePoints(fileNameOf(a), fileNameOf(b));
-    if (c !== 0)
-        return c;
-    c = a.pos - b.pos;
+    const c = compareCodePoints(fileNameOf(a), fileNameOf(b));
+    return c !== 0 ? c : compareDiagnosticsInFile(a, b);
+}
+/** `compareDiagnostics` of two diagnostics whose files have the same name. */
+function compareDiagnosticsInFile(a, b) {
+    let c = a.pos - b.pos;
     if (c !== 0)
         return c;
     c = a.end - b.end;
@@ -486,6 +494,66 @@ export function compareDiagnostics(a, b) {
         return c;
     return compareRelatedInfo(a.relatedInformation, b.relatedInformation);
 }
+/**
+ * `diagnostics` in the order of `compareDiagnostics`, equal ones in their order in `diagnostics`. File
+ * names are compared once per pair of files rather than once per pair of diagnostics: the distinct
+ * files are sorted by name, and each diagnostic sorts by its file's place in that order, then by the
+ * rest of `compareDiagnostics`. A program's diagnostics come a file at a time, so the files are found
+ * from the runs of one file.
+ */
+export function sortDiagnostics(diagnostics) {
+    const n = diagnostics.length;
+    if (n < 2)
+        return diagnostics.slice();
+    const fileIndices = new Map();
+    const files = [];
+    const fileOf = [];
+    let last = undefined;
+    let lastIndex = -1;
+    for (let i = 0; i < n; i++) {
+        const file = diagnostics[i].file;
+        if (lastIndex < 0 || file !== last) {
+            let k = fileIndices.get(file);
+            if (k === undefined) {
+                k = files.length;
+                fileIndices.set(file, k);
+                files.push(file);
+            }
+            last = file;
+            lastIndex = k;
+        }
+        fileOf.push(lastIndex);
+    }
+    // Files with the same name share a rank, as they compare equal.
+    const nameOf = (k) => {
+        const file = files[k];
+        return file === undefined ? '' : file.fileName;
+    };
+    const byName = [];
+    for (let k = 0; k < files.length; k++)
+        byName.push(k);
+    byName.sort((x, y) => compareCodePoints(nameOf(x), nameOf(y)));
+    const rank = [];
+    for (let k = 0; k < files.length; k++)
+        rank.push(0);
+    for (let k = 1; k < byName.length; k++)
+        rank[byName[k]] = rank[byName[k - 1]] + (nameOf(byName[k]) === nameOf(byName[k - 1]) ? 0 : 1);
+    const order = [];
+    for (let i = 0; i < n; i++)
+        order.push(i);
+    order.sort((x, y) => {
+        const c = rank[fileOf[x]] - rank[fileOf[y]];
+        if (c !== 0)
+            return c;
+        const a = diagnostics[x];
+        const b = diagnostics[y];
+        return a === b ? 0 : compareDiagnosticsInFile(a, b);
+    });
+    const sorted = [];
+    for (const i of order)
+        sorted.push(diagnostics[i]);
+    return sorted;
+}
 function equalChain(a, b) {
     if (a.length !== b.length)
         return false;
@@ -567,13 +635,27 @@ function formatDiagnosticIn(diagnostic, fileName, options) {
     result += `${categoryName(diagnostic.category)} TS${diagnostic.code}: `;
     return result + flattenDiagnosticMessage(diagnostic, options.newLine, options.locale) + options.newLine;
 }
+/**
+ * The plain format the main thread reports a compilation's diagnostics in (`DiagnosticReporter.plainFormat`),
+ * which its checker threads receive a copy of and format the diagnostics they send back in
+ * (`Diagnostic.formatted`). Unset where diagnostics are reported with color and context, or not at all.
+ */
+export class FormattedReports {
+    format = undefined;
+}
+export const formattedReports = new FormattedReports();
 /** `formatDiagnostic` of each diagnostic. */
 export function formatDiagnostics(diagnostics, options) {
     let result = '';
+    const formatted = options === formattedReports.format;
     // Sorted diagnostics come a file at a time: the relative name of the last file is kept.
     let lastFile = undefined;
     let lastName = '';
     for (const diagnostic of diagnostics) {
+        if (formatted && diagnostic.formatted !== '') {
+            result += diagnostic.formatted;
+            continue;
+        }
         const file = diagnostic.file;
         if (file !== undefined && file !== lastFile) {
             lastFile = file;

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

@@ -147,6 +147,11 @@ export declare class ProcessedFiles {
      * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
      */
     readonly preparedPackageJsons: readonly PackageJsonLookup[] | undefined;
+    /**
+     * The files each file's imports and type reference directives added to the program, by index into
+     * `files`, without the file itself.
+     */
+    readonly addedFiles: readonly (readonly number[])[];
     constructor(resolver: Resolver, 
     /** Libraries first, sorted, then other files in load order. */
     files: readonly SourceFile[], filesByPath: ReadonlyMap<string, SourceFile>, missingFiles: readonly string[], resolvedModules: ReadonlyMap<string, ModeAwareCache<ResolvedModule> | undefined>, typeResolutionsInFile: ReadonlyMap<string, ModeAwareCache<ResolvedTypeReferenceDirective> | undefined>, sourceFileMetadata: ReadonlyMap<string, SourceFileMetadata>, jsxRuntimeImports: ReadonlyMap<string, JsxRuntimeImport>, importHelpersImportSpecifiers: ReadonlyMap<string, StringLiteral>, libFiles: ReadonlyMap<string, LibFile>, 
@@ -158,7 +163,12 @@ export declare class ProcessedFiles {
      * The `package.json` lookups made resolving the files whose resolutions were taken from parse
      * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
      */
-    preparedPackageJsons: readonly PackageJsonLookup[] | undefined);
+    preparedPackageJsons: readonly PackageJsonLookup[] | undefined, 
+    /**
+     * The files each file's imports and type reference directives added to the program, by index into
+     * `files`, without the file itself.
+     */
+    addedFiles: readonly (readonly number[])[]);
 }
 /** The files of `processed` with `file` in place of the file at its path, for `Program.updateFile`. */
 export declare function withReplacedFile(processed: ProcessedFiles, file: SourceFile): ProcessedFiles;