tsc-ts 0.0.8 → 0.0.9

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

@@ -702,8 +702,12 @@ export function resolveDeclaredMembers(c, t) {
         const members = getMembersOfSymbol(c, t.symbol);
         declared.declaredMembersResolved = true;
         declared.declaredMembers = members;
-        declared.declaredCallSignatures = getSignaturesOfSymbol(c, members.get("\uFFFEcall" /* InternalSymbolName.Call */));
-        declared.declaredConstructSignatures = getSignaturesOfSymbol(c, members.get("\uFFFEnew" /* InternalSymbolName.New */));
+        // Most interfaces declare neither, and share one empty list.
+        const call = members.get("\uFFFEcall" /* InternalSymbolName.Call */);
+        const construct = members.get("\uFFFEnew" /* InternalSymbolName.New */);
+        declared.declaredCallSignatures = call !== undefined ? getSignaturesOfSymbol(c, call) : emptySignatures;
+        declared.declaredConstructSignatures =
+            construct !== undefined ? getSignaturesOfSymbol(c, construct) : emptySignatures;
         declared.declaredIndexInfos = getIndexInfosOfSymbol(c, t.symbol);
     }
     return declared;

package/dist/api/compiler/checker-source-file.d.ts

@@ -5,6 +5,18 @@ import type { Checker } from './checker.js';
  * identifiers, which need the whole file checked first.
  */
 export declare function checkSourceFile(c: Checker, file: SourceFile, checkUnused?: boolean): void;
+/**
+ * Checks the statements `start` to `end` of the declaration file `file`, one of the ranges that several
+ * checkers check it in (parallel-check.ts), and returns whether the checker then has diagnostics in the
+ * file. The range ending the file also runs the checks of the whole file. The file is not marked checked.
+ *
+ * When no range finds a diagnostic in the file, checking it whole would find none either: each statement
+ * is checked by the checker of its range. Otherwise the file is checked whole (`startParallelCheck`): the
+ * diagnostics of the ranges can differ from the file's, where they depend on the order the file's
+ * declarations are resolved in. A union type prints its members in the order the checker created them,
+ * and a check that a symbol's first declaration runs reports on all its declarations.
+ */
+export declare function checkSourceFileRange(c: Checker, file: SourceFile, start: number, end: number): boolean;
 /** Checks a statement, declaration, class member or type node. */
 export declare function checkSourceElement(c: Checker, node: Node | undefined): void;
 /** Resolves the `@link` names of a node's JSDoc, which marks what they name referenced. */

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

@@ -81,6 +81,41 @@ function checkSourceFileWorker(c, file) {
     links.typeChecked = true;
     links.deferredNodes = undefined;
 }
+/**
+ * Checks the statements `start` to `end` of the declaration file `file`, one of the ranges that several
+ * checkers check it in (parallel-check.ts), and returns whether the checker then has diagnostics in the
+ * file. The range ending the file also runs the checks of the whole file. The file is not marked checked.
+ *
+ * When no range finds a diagnostic in the file, checking it whole would find none either: each statement
+ * is checked by the checker of its range. Otherwise the file is checked whole (`startParallelCheck`): the
+ * diagnostics of the ranges can differ from the file's, where they depend on the order the file's
+ * declarations are resolved in. A union type prints its members in the order the checker created them,
+ * and a check that a symbol's first declaration runs reports on all its declarations.
+ */
+export function checkSourceFileRange(c, file, start, end) {
+    const statements = getStatements(file).nodes;
+    c.fileBeingChecked = file;
+    c.saveDeferredDiagnostics = true;
+    for (let i = start; i < end; i++)
+        checkSourceElement(c, statements[i]);
+    checkDeferredNodes(c, file);
+    const whole = end === statements.length;
+    if (whole && isExternalOrCommonJSModule(file))
+        checkExternalModuleExports(c, file);
+    c.renamedBindingElementsInTypes.length = 0;
+    if (whole) {
+        checkGrammarSourceFile(c, file);
+        checkDeferredNodes(c, file);
+        checkPendingExternalEmitHelpers(c, file);
+    }
+    c.fileBeingChecked = undefined;
+    c.saveDeferredDiagnostics = false;
+    produceDeferredIterationErrors(c);
+    produceDeferredCollisionChecks(c);
+    // Deferred nodes of a later range are queued again (checkNodeDeferred).
+    c.nodeLinks(file).deferredNodes = undefined;
+    return c.diagnostics.forFile(file.fileName).length > 0;
+}
 /** Checks a statement, declaration, class member or type node. */
 export function checkSourceElement(c, node) {
     if (node === undefined)

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

@@ -697,6 +697,7 @@ function setMergedSymbol(c, id, target) {
         c.mergedSymbolChanges.set(c.mergedSymbols, id, target);
     else
         c.mergedSymbols.set(id, target);
+    c.mergedSymbolIds.add(id);
 }
 /** Merges script locals into globals; ambient modules and augmentations wait for global types. */
 export function initializeGlobals(c) {
@@ -1033,7 +1034,7 @@ function recordMergedSymbol(c, target, source) {
 }
 export function getMergedSymbol(c, symbol) {
     const id = symbol.id;
-    if (id !== 0) {
+    if (id !== 0 && c.mergedSymbolIds.has(id)) {
         const merged = c.mergedSymbols.get(id);
         if (merged !== undefined)
             return merged;

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

@@ -1,7 +1,7 @@
 import type { DeferredCollisionCheck } from './checker-generated-code.js';
 import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
 import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.js';
 import { type CompilerOptions, ModuleKind, ScriptTarget } from './options.js';
 import { CheckFlags, Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
@@ -204,6 +204,11 @@ export declare class Checker implements TypeChecking {
     readonly resolvedSignatures: SparseLinkTable<Signature>;
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     readonly mergedSymbols: Map<number, Symbol>;
+    /**
+     * The ids that `mergedSymbols` has, or had: most symbols are merged into none, and `getMergedSymbol`
+     * finds that here without probing the map.
+     */
+    readonly mergedSymbolIds: PagedIdSet;
     /** Globals merged from the default libraries, shared with other checkers. */
     libGlobals: LibGlobals | undefined;
     /** The program's globals and module augmentations as another checker merged them, shared with it. */

package/dist/api/compiler/checker.js

@@ -1,5 +1,5 @@
 import { sideOf } from './side-state.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
 import { Diagnostic, compareDiagnostics } from './diagnostics.js';
 import { ModuleKind, ScriptTarget, getEmitScriptTarget, getIsolatedModules, getStrictOptionValue, shouldPreserveConstEnums, } from './options.js';
@@ -284,6 +284,11 @@ export class Checker {
     resolvedSignatures = new SparseLinkTable();
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     mergedSymbols;
+    /**
+     * The ids that `mergedSymbols` has, or had: most symbols are merged into none, and `getMergedSymbol`
+     * finds that here without probing the map.
+     */
+    mergedSymbolIds = new PagedIdSet();
     /** Globals merged from the default libraries, shared with other checkers. */
     libGlobals;
     /** The program's globals and module augmentations as another checker merged them, shared with it. */
@@ -616,6 +621,8 @@ export class Checker {
             this.globals = libs.copyGlobals();
             this.mergedSymbols = libs.copyMergedSymbols();
         }
+        for (const id of this.mergedSymbols.keys())
+            this.mergedSymbolIds.add(id);
         this.globalThisSymbol = this.newSymbol(1536 /* SymbolFlags.Module */, 'globalThis');
         this.globalThisSymbol.checkFlags = 8 /* CheckFlags.Readonly */;
         this.globalThisSymbol.exports = this.globals;
@@ -890,6 +897,7 @@ export function disposeChecker(c) {
         c.mergedSymbols.clear();
         c.globals.clear();
     }
+    c.mergedSymbolIds.clear();
     c.sharedSymbolCopies.clear();
     c.memberPositionsInLists.clear();
     c.memberNamesOfLists.clear();

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

@@ -95,10 +95,10 @@ export declare class LoadedFile {
     readonly references: LoadedReference[];
     readonly resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined;
     readonly typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined;
-    readonly processingDiagnostics: ProcessingDiagnostic[];
+    readonly processingDiagnostics: readonly ProcessingDiagnostic[];
     readonly importHelpersImportSpecifier: StringLiteral | undefined;
     readonly jsxRuntimeImport: JsxRuntimeImport | undefined;
-    constructor(file: SourceFile, isLibFile: boolean, metadata: SourceFileMetadata, references: LoadedReference[], resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined, typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined, processingDiagnostics: ProcessingDiagnostic[], importHelpersImportSpecifier: StringLiteral | undefined, jsxRuntimeImport: JsxRuntimeImport | undefined);
+    constructor(file: SourceFile, isLibFile: boolean, metadata: SourceFileMetadata, references: LoadedReference[], resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined, typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined, processingDiagnostics: readonly ProcessingDiagnostic[], importHelpersImportSpecifier: StringLiteral | undefined, jsxRuntimeImport: JsxRuntimeImport | undefined);
 }
 /** Referenced projects, and how their sources map to declaration outputs. */
 export declare class ProjectReferenceMapper {

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

@@ -165,6 +165,14 @@ class SubTasksAhead {
         this.subTasks = subTasks;
     }
 }
+/** Read in place of a task's lists it has not created. */
+const noParseTasks = [];
+const noTraces = [];
+const noProcessingDiagnostics = [];
+/**
+ * A file to load. Its lists are created on first use: most tasks never get sub-tasks, traces or processing
+ * diagnostics, and large programs create hundreds of thousands of tasks.
+ */
 class ParseTask {
     normalizedFilePath;
     libFile;
@@ -176,15 +184,15 @@ class ParseTask {
     path = '';
     file = undefined;
     redirectedParseTask = undefined;
-    subTasks = [];
+    subTasks = undefined;
     loaded = false;
     startedSubTasks = false;
     metadata = libFileMetadata;
     resolutionsInFile = undefined;
-    resolutionsTrace = [];
+    resolutionsTrace = undefined;
     typeResolutionsInFile = undefined;
-    typeResolutionsTrace = [];
-    processingDiagnostics = [];
+    typeResolutionsTrace = undefined;
+    processingDiagnostics = undefined;
     importHelpersImportSpecifier = undefined;
     jsxRuntimeImport = undefined;
     /** The task of the same file name that was loaded instead of this one. */
@@ -201,7 +209,18 @@ class ParseTask {
         this.packageId = packageId;
     }
     addSubTask(fileName, libFile, reason, increaseDepth, elideOnDepth, packageId) {
-        this.subTasks.push(new ParseTask(normalizePath(fileName), libFile, reason, false, increaseDepth, elideOnDepth, packageId));
+        (this.subTasks ??= []).push(new ParseTask(normalizePath(fileName), libFile, reason, false, increaseDepth, elideOnDepth, packageId));
+    }
+    addProcessingDiagnostic(diagnostic) {
+        (this.processingDiagnostics ??= []).push(diagnostic);
+    }
+    /** Where module resolution traces go under `--traceResolution`; undefined without it. */
+    moduleTraces(trace) {
+        return trace ? (this.resolutionsTrace ??= []) : undefined;
+    }
+    /** Where type reference resolution traces go under `--traceResolution`; undefined without it. */
+    typeTraces(trace) {
+        return trace ? (this.typeResolutionsTrace ??= []) : undefined;
     }
 }
 /** The tasks of one path, by file name casing. */
@@ -640,7 +659,7 @@ export class FileLoader {
             return undefined;
         }
         const references = [];
-        for (const sub of task.subTasks) {
+        for (const sub of task.subTasks ?? noParseTasks) {
             references.push(new LoadedReference(sub.normalizedFilePath, sub.libFile !== undefined ? sub.libFile.name : '', sub.includeReason, sub.increaseDepth, sub.elideOnDepth, sub.packageId));
             const subDepth = sub.increaseDepth ? depth + 1 : depth;
             // `run` skips these.
@@ -655,7 +674,7 @@ export class FileLoader {
         // Traces are reported in the program's order: such programs resolve on their own.
         if (file === undefined || this.options.traceResolution === true)
             return undefined;
-        return new LoadedFile(file, task.libFile !== undefined, task.metadata, references, task.resolutionsInFile, task.typeResolutionsInFile, task.processingDiagnostics, task.importHelpersImportSpecifier, task.jsxRuntimeImport);
+        return new LoadedFile(file, task.libFile !== undefined, task.metadata, references, task.resolutionsInFile, task.typeResolutionsInFile, task.processingDiagnostics ?? noProcessingDiagnostics, task.importHelpersImportSpecifier, task.jsxRuntimeImport);
     }
     // ---- Project references
     loadProjectReferences() {
@@ -737,7 +756,7 @@ export class FileLoader {
             return;
         }
         const task = new ParseTask(absolute, undefined, reason, false, false, false, undefined);
-        task.processingDiagnostics.push(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
+        task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
         this.rootTasks.push(task);
     }
     isSupportedExtension(canonicalFileName) {
@@ -888,7 +907,8 @@ export class FileLoader {
             }
             if (!taskByFileName.startedSubTasks && loadSubTasks) {
                 taskByFileName.startedSubTasks = true;
-                this.start(taskByFileName.subTasks, data.lowestDepth);
+                if (taskByFileName.subTasks !== undefined)
+                    this.start(taskByFileName.subTasks, data.lowestDepth);
             }
         }
     }
@@ -921,7 +941,7 @@ export class FileLoader {
         if (hasExtension(task.normalizedFilePath) && this.options.allowNonTsExtensions !== true) {
             const canonicalFileName = getCanonicalFileName(task.normalizedFilePath, fs.useCaseSensitiveFileNames);
             if (!this.isSupportedExtension(canonicalFileName)) {
-                task.processingDiagnostics.push(hasJSFileExtension(canonicalFileName)
+                task.addProcessingDiagnostic(hasJSFileExtension(canonicalFileName)
                     ? ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1519 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [task.normalizedFilePath])
                     : ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1230 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [task.normalizedFilePath, this.supportedExtensionsList()]));
                 return;
@@ -955,7 +975,7 @@ export class FileLoader {
                 const reason = FileIncludeReason.reference(3 /* FileIncludeKind.LibReferenceDirective */, task.path, i, undefined);
                 const name = getLibFileName(file.libReferenceDirectives[i].fileName);
                 if (name === '') {
-                    task.processingDiagnostics.push(ProcessingDiagnostic.unknownReference(reason));
+                    task.addProcessingDiagnostic(ProcessingDiagnostic.unknownReference(reason));
                     continue;
                 }
                 const libFile = this.pathForLibFile(name);
@@ -975,7 +995,7 @@ export class FileLoader {
         else
             task.subTasks = this.subTasksOf(loaded);
         for (const diagnostic of loaded.processingDiagnostics)
-            task.processingDiagnostics.push(diagnostic.copy());
+            task.addProcessingDiagnostic(diagnostic.copy());
         task.resolutionsInFile = loaded.resolutionsInFile;
         task.typeResolutionsInFile = loaded.typeResolutionsInFile;
         task.importHelpersImportSpecifier = loaded.importHelpersImportSpecifier;
@@ -1002,7 +1022,7 @@ export class FileLoader {
         const reason = FileIncludeReason.reference(1 /* FileIncludeKind.ReferenceFile */, this.toPath(containingFile), index, undefined);
         const resolved = this.getSourceFileFromReference(normalizePath(referencedFileName), moduleName, containingFile, reason);
         if (typeof resolved !== 'string') {
-            task.processingDiagnostics.push(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
+            task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
             return;
         }
         task.addSubTask(resolved, undefined, reason, false, false, undefined);
@@ -1020,14 +1040,14 @@ export class FileLoader {
             const mode = reference.resolutionMode !== ModuleKind.None
                 ? reference.resolutionMode
                 : getDefaultResolutionModeForFile(file.fileName, task.metadata, options);
-            const resolved = this.resolver.resolveTypeReferenceDirective(reference.fileName, containingFile, mode, redirect?.resolved, task.typeResolutionsTrace);
+            const resolved = this.resolver.resolveTypeReferenceDirective(reference.fileName, containingFile, mode, redirect?.resolved, task.typeTraces(this.options.traceResolution === true));
             resolutions.set(modeAwareKey(reference.fileName, mode), resolved);
             const reason = FileIncludeReason.reference(2 /* FileIncludeKind.TypeReferenceDirective */, task.path, i, undefined);
             if (resolved.resolvedFileName !== '') {
                 task.addSubTask(resolved.resolvedFileName, undefined, reason, resolved.isExternalLibraryImport, false, resolved.packageId);
             }
             else {
-                task.processingDiagnostics.push(ProcessingDiagnostic.unknownReference(reason));
+                task.addProcessingDiagnostic(ProcessingDiagnostic.unknownReference(reason));
             }
         }
         task.typeResolutionsInFile = resolutions;
@@ -1039,13 +1059,13 @@ export class FileLoader {
         const resolutions = new Map();
         for (const name of names) {
             // Resolved without a mode: CommonJS under node16/nodenext, `import` conditions under bundler.
-            const resolved = this.resolver.resolveTypeReferenceDirective(name, task.normalizedFilePath, ModuleKind.None, undefined, task.typeResolutionsTrace);
+            const resolved = this.resolver.resolveTypeReferenceDirective(name, task.normalizedFilePath, ModuleKind.None, undefined, task.typeTraces(this.options.traceResolution === true));
             resolutions.set(modeAwareKey(name, ModuleKind.None), resolved);
             if (resolved.resolvedFileName !== '') {
                 task.addSubTask(resolved.resolvedFileName, undefined, FileIncludeReason.automaticTypeDirective(name, resolved.packageId), resolved.isExternalLibraryImport, false, resolved.packageId);
             }
             else {
-                task.processingDiagnostics.push(ProcessingDiagnostic.explainingFileInclude('', FileIncludeReason.automaticTypeDirective(name, undefined), 821 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, [name]));
+                task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', FileIncludeReason.automaticTypeDirective(name, undefined), 821 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, [name]));
             }
         }
         task.typeResolutionsInFile = resolutions;
@@ -1083,7 +1103,7 @@ export class FileLoader {
             if (moduleName === '')
                 continue;
             const mode = getModeForUsageLocation(file.fileName, task.metadata, entry, options);
-            const resolved = this.resolver.resolveModuleName(moduleName, containingFile, mode, redirect?.resolved, task.resolutionsTrace);
+            const resolved = this.resolver.resolveModuleName(moduleName, containingFile, mode, redirect?.resolved, task.moduleTraces(this.options.traceResolution === true));
             resolutions.set(modeAwareKey(moduleName, mode), resolved);
             const resolvedFileName = resolved.resolvedFileName;
             if (resolvedFileName === '')
@@ -1169,9 +1189,9 @@ export class FileLoader {
                         tasksSeenByNameIgnoreCase.set(lowerCasePath, task);
                     }
                 }
-                for (const trace of task.typeResolutionsTrace)
+                for (const trace of task.typeResolutionsTrace ?? noTraces)
                     host.trace(trace);
-                for (const trace of task.resolutionsTrace)
+                for (const trace of task.resolutionsTrace ?? noTraces)
                     host.trace(trace);
                 const file = task.file;
                 const packageId = data.packageId;
@@ -1193,7 +1213,7 @@ export class FileLoader {
                     if (file !== undefined)
                         packageIdToSourceFile.set(key, file);
                 }
-                if (task.subTasks.length > 0)
+                if (task.subTasks !== undefined && task.subTasks.length > 0)
                     collectFiles(task.subTasks);
                 const redirected = task.redirectedParseTask;
                 if (redirected !== undefined) {
@@ -1202,12 +1222,12 @@ export class FileLoader {
                 }
                 if (task.isForAutomaticTypeDirective) {
                     typeResolutionsInFile.set(task.path, task.typeResolutionsInFile);
-                    for (const diagnostic of task.processingDiagnostics)
+                    for (const diagnostic of task.processingDiagnostics ?? noProcessingDiagnostics)
                         includeProcessor.addProcessingDiagnostic(diagnostic);
                     continue;
                 }
                 const path = task.path;
-                for (const diagnostic of task.processingDiagnostics)
+                for (const diagnostic of task.processingDiagnostics ?? noProcessingDiagnostics)
                     includeProcessor.addProcessingDiagnostic(diagnostic);
                 if (file === undefined) {
                     missingFiles.push(task.normalizedFilePath);

package/dist/api/compiler/link-tables.d.ts

@@ -58,6 +58,13 @@ export declare class ClusteredIntLinkTable {
     set(id: number, value: number): void;
     private pageOf;
 }
+/** Ids in pages of `IdSetPaging.Ids` ids, one bit each; a page is created by the first id added to it. */
+export declare class PagedIdSet {
+    readonly pages: (Int32Array | undefined)[];
+    has(id: number): boolean;
+    add(id: number): void;
+    clear(): void;
+}
 /**
  * A page of a `CompactSymbolLinkTable`: one bit per id of the page in eight 32-id words, the number
  * of symbols stored before each word, and the symbols in id order. The words are fields, so a

package/dist/api/compiler/link-tables.js

@@ -146,6 +146,28 @@ export class ClusteredIntLinkTable {
         return this.lastPage;
     }
 }
+/** Ids in pages of `IdSetPaging.Ids` ids, one bit each; a page is created by the first id added to it. */
+export class PagedIdSet {
+    pages = [];
+    has(id) {
+        const page = this.pages[id >> 13 /* IdSetPaging.Bits */];
+        return page !== undefined && (page[(id >> 5) & 255 /* IdSetPaging.WordMask */] & (1 << (id & 31))) !== 0;
+    }
+    add(id) {
+        const index = id >> 13 /* IdSetPaging.Bits */;
+        let page = this.pages[index];
+        if (page === undefined) {
+            while (this.pages.length <= index)
+                this.pages.push(undefined);
+            page = new Int32Array(256 /* IdSetPaging.Words */);
+            this.pages[index] = page;
+        }
+        page[(id >> 5) & 255 /* IdSetPaging.WordMask */] |= 1 << (id & 31);
+    }
+    clear() {
+        this.pages.length = 0;
+    }
+}
 /** The number of set bits of a 32-bit value. */
 function bitCount(x) {
     x = x - ((x >>> 1) & 0x55555555);

package/dist/api/compiler/parser.js

@@ -3010,17 +3010,12 @@ export class Parser extends ScannerErrorReporter {
         return false;
     }
     parseTypeOrTypePredicate() {
-        if (this.isIdentifier()) {
-            const state = this.beginSpeculation();
+        // `x is T`: the identifier is parsed only once `is` is known to follow it.
+        if (this.isIdentifier() && this.lookAhead(nextTokenIsIsKeywordOnSameLine)) {
             const pos = this.nodePos();
             const id = this.parseIdentifier(1 /* IdentifierUse.Name */);
-            if (this.token() === 142 /* SyntaxKind.IsKeyword */ && !this.hasPrecedingLineBreak()) {
-                this.endSpeculation(state);
-                this.nextToken();
-                return this.finishNode(new TypePredicateNode(undefined, id, this.parseType()), pos);
-            }
-            this.rewind(state);
-            this.endSpeculation(state);
+            this.nextToken();
+            return this.finishNode(new TypePredicateNode(undefined, id, this.parseType()), pos);
         }
         return this.parseType();
     }
@@ -5982,6 +5977,9 @@ function nextTokenCanFollowExportModifier(p) {
 function nextTokenIsClassKeywordOnSameLine(p) {
     return p.nextToken() === 85 /* SyntaxKind.ClassKeyword */ && !p.hasPrecedingLineBreak();
 }
+function nextTokenIsIsKeywordOnSameLine(p) {
+    return p.nextToken() === 142 /* SyntaxKind.IsKeyword */ && !p.hasPrecedingLineBreak();
+}
 function nextTokenIsFunctionKeywordOnSameLine(p) {
     return p.nextToken() === 99 /* SyntaxKind.FunctionKeyword */ && !p.hasPrecedingLineBreak();
 }
@@ -6034,11 +6032,14 @@ function nextIsUnParenthesizedAsyncArrowFunction(p) {
         // `async =>` is a simple arrow function with a parameter named `async`.
         if (p.hasPrecedingLineBreak() || p.token() === 38 /* SyntaxKind.EqualsGreaterThanToken */)
             return false;
-        const expr = p.parseBinaryExpressionOrHigher(0 /* OperatorPrecedence.Lowest */);
-        if (!p.hasPrecedingLineBreak() &&
-            expr.kind === 79 /* SyntaxKind.Identifier */ &&
-            p.token() === 38 /* SyntaxKind.EqualsGreaterThanToken */)
-            return true;
+        // The binary expression after `async` is a lone identifier followed by `=>` only when an identifier
+        // token is followed by `=>`. Any other first token starts another kind of expression or none, and any
+        // other token after the identifier continues the expression or ends it before `=>`. Checking the
+        // tokens gives the same answer as parsing the expression, whose nodes would be discarded.
+        if (!p.isIdentifier())
+            return false;
+        p.nextToken();
+        return !p.hasPrecedingLineBreak() && p.token() === 38 /* SyntaxKind.EqualsGreaterThanToken */;
     }
     return false;
 }

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

@@ -134,6 +134,23 @@ export declare class CheckedProgram {
      * incremental program keeps them unfiltered under `noEmit` too.
      */
     unfilteredDiagnosticsOfFile(file: SourceFile): Diagnostic[];
+    /**
+     * Checks the statements `start` to `end` of the declaration file `file` with this checker, one of the
+     * ranges that several checkers check it in (`checkSourceFileRange`, parallel-check.ts), and returns
+     * whether the checker then has diagnostics in the file.
+     */
+    checkRange(file: SourceFile, start: number, end: number): boolean;
+    /**
+     * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, where checkers checked it in
+     * ranges and found no diagnostics in it (`checkRange`).
+     */
+    unfilteredDiagnosticsOfCleanRanges(file: SourceFile): Diagnostic[];
+    /**
+     * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, from a new checker that checks it
+     * whole: for a file checked in ranges that found diagnostics in it (parallel-check.ts), part of which this
+     * thread's checker may have checked.
+     */
+    unfilteredDiagnosticsOfFileOnNewChecker(file: SourceFile): Diagnostic[];
     /**
      * The bind and check diagnostics of `file` before `noEmit` filtering and without include errors.
      * Once checker threads checked the program, they come from the threads' diagnostics of the file,
@@ -156,6 +173,7 @@ export declare class CheckedProgram {
     skipTypeChecking(file: SourceFile): boolean;
     private collect;
     private collectChecked;
+    /** `checks` are the checker's diagnostics of `file`. */
     private getBindAndCheckDiagnostics;
     getIncludeProcessorDiagnostics(file: SourceFile): Diagnostic[];
 }

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

@@ -4,6 +4,7 @@ import { ModuleSpecifierHost } from './module-specifiers.js';
 import { sortAndDeduplicateDiagnostics } from './program.js';
 import { getEmitModuleFormatOfFile, getEmitSyntaxForUsageLocation, isCheckJsEnabledForFile, } from './program-utilities.js';
 import { bindSourceFile } from './binder.js';
+import { checkSourceFileRange } from './checker-source-file.js';
 import { computeLineOfPosition } from './scanner.js';
 /** What the checker needs, answered by a program. */
 export class ProgramCheckerHost extends CheckerHost {
@@ -250,6 +251,37 @@ export class CheckedProgram {
             result.push(d);
         return result;
     }
+    /**
+     * Checks the statements `start` to `end` of the declaration file `file` with this checker, one of the
+     * ranges that several checkers check it in (`checkSourceFileRange`, parallel-check.ts), and returns
+     * whether the checker then has diagnostics in the file.
+     */
+    checkRange(file, start, end) {
+        return checkSourceFileRange(this.checker, file, start, end);
+    }
+    /**
+     * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, where checkers checked it in
+     * ranges and found no diagnostics in it (`checkRange`).
+     */
+    unfilteredDiagnosticsOfCleanRanges(file) {
+        const result = this.getBindAndCheckDiagnostics(file, []);
+        for (const d of this.getIncludeProcessorDiagnostics(file))
+            result.push(d);
+        return result;
+    }
+    /**
+     * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, from a new checker that checks it
+     * whole: for a file checked in ranges that found diagnostics in it (parallel-check.ts), part of which this
+     * thread's checker may have checked.
+     */
+    unfilteredDiagnosticsOfFileOnNewChecker(file) {
+        const checker = this.createChecker();
+        const result = this.getBindAndCheckDiagnostics(file, checker.getDiagnostics(file));
+        disposeChecker(checker);
+        for (const d of this.getIncludeProcessorDiagnostics(file))
+            result.push(d);
+        return result;
+    }
     /**
      * The bind and check diagnostics of `file` before `noEmit` filtering and without include errors.
      * Once checker threads checked the program, they come from the threads' diagnostics of the file,
@@ -331,10 +363,11 @@ export class CheckedProgram {
         }
         return sortAndDeduplicateDiagnostics(result);
     }
-    getBindAndCheckDiagnostics(file) {
+    /** `checks` are the checker's diagnostics of `file`. */
+    getBindAndCheckDiagnostics(file, checks) {
         const options = this.program.options;
         const diagnostics = file.bindDiagnostics.slice();
-        for (const d of this.checker.getDiagnostics(file))
+        for (const d of checks ?? this.checker.getDiagnostics(file))
             diagnostics.push(d);
         if (isPlainJSFile(file, options)) {
             const result = [];

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

@@ -11,3 +11,13 @@ export declare function diagnosticOf(d: CompilerDiagnostic): Diagnostic;
  * them. Declaration diagnostics are empty, as tsgo's API returns them.
  */
 export declare function programDiagnostics(checked: CheckedProgram, kind: DiagnosticKind, file: SourceFile | undefined): readonly CompilerDiagnostic[];
+/**
+ * What `semantic` answers for each of `files` and what `global` answers, after checking `files` and
+ * no other file. Checking one file can add diagnostics located in another, so every file is checked
+ * before any file's diagnostics are collected. With every file of the program listed, the answers are
+ * those of the full check.
+ */
+export declare function checkedFileDiagnostics(checked: CheckedProgram, files: readonly SourceFile[]): {
+    files: (readonly CompilerDiagnostic[])[];
+    global: readonly CompilerDiagnostic[];
+};

package/dist/api/library/diagnostics.js

@@ -48,3 +48,23 @@ export function programDiagnostics(checked, kind, file) {
             return [];
     }
 }
+/**
+ * What `semantic` answers for each of `files` and what `global` answers, after checking `files` and
+ * no other file. Checking one file can add diagnostics located in another, so every file is checked
+ * before any file's diagnostics are collected. With every file of the program listed, the answers are
+ * those of the full check.
+ */
+export function checkedFileDiagnostics(checked, files) {
+    for (const file of files)
+        checked.getSemanticDiagnostics(file);
+    const program = checked.program;
+    const global = [
+        ...program.getConfigFileParsingDiagnostics(),
+        ...program.getProgramDiagnostics(),
+        ...checked.getGlobalDiagnostics(),
+    ];
+    return {
+        files: files.map((file) => checked.getSemanticDiagnostics(file)),
+        global: sortAndDeduplicateDiagnostics(global).filter((d) => d.file === undefined),
+    };
+}

package/package.json

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

package/src/compiler/checker-members.ts

@@ -923,8 +923,12 @@ export function resolveDeclaredMembers(c: Checker, t: InterfaceType): InterfaceT
     const members = getMembersOfSymbol(c, t.symbol!);
     declared.declaredMembersResolved = true;
     declared.declaredMembers = members;
-    declared.declaredCallSignatures = getSignaturesOfSymbol(c, members.get(InternalSymbolName.Call));
-    declared.declaredConstructSignatures = getSignaturesOfSymbol(c, members.get(InternalSymbolName.New));
+    // Most interfaces declare neither, and share one empty list.
+    const call = members.get(InternalSymbolName.Call);
+    const construct = members.get(InternalSymbolName.New);
+    declared.declaredCallSignatures = call !== undefined ? getSignaturesOfSymbol(c, call) : emptySignatures;
+    declared.declaredConstructSignatures =
+      construct !== undefined ? getSignaturesOfSymbol(c, construct) : emptySignatures;
     declared.declaredIndexInfos = getIndexInfosOfSymbol(c, t.symbol!);
   }
   return declared;