tsc-ts 0.0.9 → 0.1.0

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;
@@ -83,6 +105,11 @@ export declare abstract class CompilerProgram {
     readonly times: CompileTimes;
     readonly emitter: ProgramEmitter;
     constructor(checked: CheckedProgram, times: CompileTimes);
+    /**
+     * The time spent in declaration emit while checking, to count as emit time rather than check time, since
+     * the last call. Only an incremental program emits while checking, to compute signatures.
+     */
+    takeNestedEmitTime(): number;
     get program(): Program;
     get options(): CompilerOptions;
     getConfigFileParsingDiagnostics(): readonly Diagnostic[];
@@ -90,6 +117,12 @@ export declare abstract class CompilerProgram {
     getProgramDiagnostics(): Diagnostic[];
     /** See `CheckedProgram.getGlobalDiagnostics`. */
     getGlobalDiagnostics(withCheckerThreads?: boolean): Diagnostic[];
+    /**
+     * Whether the global diagnostics found by checking are reported after the semantic diagnostics. An
+     * incremental program has them in the semantic diagnostics of the files they were found in
+     * (`CheckedProgram.globalsInFileDiagnostics`).
+     */
+    reportsGlobalDiagnosticsOfChecking(): boolean;
     /** Semantic diagnostics of every file. */
     abstract getSemanticDiagnostics(): Diagnostic[];
     /** Declaration emit errors of every file. */
@@ -109,10 +142,16 @@ export declare class PlainProgram extends CompilerProgram {
 /** Under `noEmitOnError`, a skipped emit with the errors that prevent it; otherwise `undefined`. */
 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`).
+ * Config and syntax errors; without syntax errors, program, global and semantic errors too, and, when
+ * there are none of these, declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With
+ * `declarationsLater`, the declaration errors are left to the caller (`declarationDiagnosticsDue`).
+ */
+export declare function getDiagnosticsOfProgram(program: CompilerProgram, withDeclarationDiagnostics: boolean, declarationsLater?: boolean): Diagnostic[];
+/**
+ * Whether `getDiagnosticsOfProgram` adds the declaration errors to `diagnostics`: under `noEmit` (or
+ * `withDeclarationDiagnostics`) with declarations, when only config errors were found.
  */
-export declare function getDiagnosticsOfProgram(program: CompilerProgram, withDeclarationDiagnostics: boolean): Diagnostic[];
+export declare function declarationDiagnosticsDue(program: CompilerProgram, diagnostics: readonly Diagnostic[], withDeclarationDiagnostics: boolean): boolean;
 /** 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;
@@ -231,6 +311,13 @@ export class CompilerProgram {
         this.times = times;
         this.emitter = new ProgramEmitter(checked);
     }
+    /**
+     * The time spent in declaration emit while checking, to count as emit time rather than check time, since
+     * the last call. Only an incremental program emits while checking, to compute signatures.
+     */
+    takeNestedEmitTime() {
+        return 0;
+    }
     get program() {
         return this.checked.program;
     }
@@ -250,6 +337,14 @@ export class CompilerProgram {
     getGlobalDiagnostics(withCheckerThreads = true) {
         return this.checked.getGlobalDiagnostics(withCheckerThreads);
     }
+    /**
+     * Whether the global diagnostics found by checking are reported after the semantic diagnostics. An
+     * incremental program has them in the semantic diagnostics of the files they were found in
+     * (`CheckedProgram.globalsInFileDiagnostics`).
+     */
+    reportsGlobalDiagnosticsOfChecking() {
+        return !this.checked.globalsInFileDiagnostics;
+    }
 }
 /** Collects declaration emit errors without writing anything. */
 class DiscardingWriter extends OutputWriter {
@@ -283,31 +378,36 @@ export class PlainProgram extends CompilerProgram {
     }
     emit(writer) {
         const options = this.options;
-        if (options.noEmit !== true) {
-            const skipped = handleNoEmitOnError(this);
-            if (skipped !== undefined)
-                return skipped;
-        }
+        // A `noEmit` program emits nothing, and its emit is not skipped (tsgo's `HandleNoEmitOptions`): its
+        // declaration errors come with its other diagnostics (`getDiagnosticsOfProgram`).
+        if (options.noEmit === true)
+            return new EmitResult();
+        const skipped = handleNoEmitOnError(this);
+        if (skipped !== undefined)
+            return skipped;
         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;
+                // The file's JavaScript is emitted too, here or on an emit thread.
+                const declarations = () => ahead?.[i] ?? this.emitter.emit([file], 4 /* EmitOnly.DtsAfterJs */, 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.
-            result.emitSkipped = files.some((file) => program.sourceFileMayBeEmitted(file, false));
-            // Declaration emit still runs for its errors, as in tsgo, also when other errors were found.
-            if (getEmitDeclarations(options) && options.noEmitOnError !== true)
-                for (const d of this.getDeclarationDiagnostics())
-                    result.diagnostics.push(d);
-        }
         return result;
     }
 }
@@ -325,10 +425,11 @@ export function handleNoEmitOnError(program) {
     return result;
 }
 /**
- * Config and syntax errors; without syntax errors, program, global and semantic errors too, and
- * declaration errors under `noEmit` (or `withDeclarationDiagnostics`).
+ * Config and syntax errors; without syntax errors, program, global and semantic errors too, and, when
+ * there are none of these, declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With
+ * `declarationsLater`, the declaration errors are left to the caller (`declarationDiagnosticsDue`).
  */
-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())
@@ -348,22 +449,33 @@ export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics) {
     if (result.length === configCount) {
         const checkStart = performance.now();
         const semantic = program.getSemanticDiagnostics();
-        program.times.checkTime = performance.now() - checkStart;
+        // Declaration emit that computed signatures while checking counts as emit time, as in TypeScript 7.1.
+        const nestedEmitTime = program.takeNestedEmitTime();
+        program.times.checkTime = Math.max(0, performance.now() - checkStart - nestedEmitTime);
+        program.times.emitTime += nestedEmitTime;
         for (const d of semantic)
             result.push(d);
         // Checking may have found more, such as missing global types.
-        for (const d of program.getGlobalDiagnostics())
-            result.push(d);
+        if (program.reportsGlobalDiagnosticsOfChecking())
+            for (const d of program.getGlobalDiagnostics())
+                result.push(d);
         mark('semantic diagnostics');
     }
-    if ((withDeclarationDiagnostics || options.noEmit === true) &&
-        getEmitDeclarations(options) &&
-        result.length === configCount) {
+    if (!declarationsLater && declarationDiagnosticsDue(program, result, withDeclarationDiagnostics))
         for (const d of program.getDeclarationDiagnostics())
             result.push(d);
-    }
     return result;
 }
+/**
+ * Whether `getDiagnosticsOfProgram` adds the declaration errors to `diagnostics`: under `noEmit` (or
+ * `withDeclarationDiagnostics`) with declarations, when only config errors were found.
+ */
+export function declarationDiagnosticsDue(program, diagnostics, withDeclarationDiagnostics) {
+    const options = program.options;
+    return ((withDeclarationDiagnostics || options.noEmit === true) &&
+        getEmitDeclarations(options) &&
+        diagnostics.length === program.getConfigFileParsingDiagnostics().length);
+}
 /** Combines emit results in order. */
 export function combineEmitResults(results) {
     const result = new EmitResult();