tsc-ts 0.0.7 → 0.0.9

package/dist/api/compiler/parser.js

@@ -147,6 +147,10 @@ export class Parser extends ScannerErrorReporter {
     // receives reparsed nodes, and a fresh array per parsed list would be one more allocation each.
     reparseLists;
     reparseDepth;
+    // One scratch array per nesting depth of the lists being parsed. A list collects its elements in
+    // its depth's array and is copied out at its exact length, so the tree keeps no spare capacity.
+    listScratch;
+    listDepth;
     reparsedClones;
     /** Nodes with eagerly parsed JSDoc, for rewinding. */
     jsDocInfos;
@@ -200,6 +204,8 @@ export class Parser extends ScannerErrorReporter {
         this.reparseList = [];
         this.reparseLists = [this.reparseList];
         this.reparseDepth = 0;
+        this.listScratch = [];
+        this.listDepth = -1;
         this.reparsedClones = [];
         this.jsDocInfos = [];
         this.jsDocTable = undefined;
@@ -610,7 +616,7 @@ export class Parser extends ScannerErrorReporter {
             this.reparseLists.push([]);
         const reparseList = this.reparseLists[depth];
         this.reparseList = reparseList;
-        const list = [];
+        const list = this.openList();
         while (!this.isListTerminator(kind)) {
             if (this.isListElement(kind, false)) {
                 const elt = this.parseListElement(element, list.length);
@@ -636,7 +642,7 @@ export class Parser extends ScannerErrorReporter {
         this.reparseDepth = depth - 1;
         this.reparseList = outerReparseList;
         this.parsingContexts = saveParsingContexts;
-        return list;
+        return this.closeList(list);
     }
     parseList(kind, element) {
         const pos = this.nodePos();
@@ -648,12 +654,13 @@ export class Parser extends ScannerErrorReporter {
         const pos = this.nodePos();
         const saveParsingContexts = this.parsingContexts;
         this.parsingContexts |= 1 << kind;
-        const list = [];
+        const list = this.openList();
         for (;;) {
             if (this.isListElement(kind, false)) {
                 const startPos = this.nodePos();
                 const result = this.parseListElement(element, list.length);
                 if (result === this.noElement) {
+                    this.closeList(list);
                     this.parsingContexts = saveParsingContexts;
                     return undefined;
                 }
@@ -683,7 +690,24 @@ export class Parser extends ScannerErrorReporter {
                 break;
         }
         this.parsingContexts = saveParsingContexts;
-        return this.newNodeList(pos, this.nodePos(), list);
+        return this.newNodeList(pos, this.nodePos(), this.closeList(list));
+    }
+    /** The scratch array for a list at the next nesting depth, empty. */
+    openList() {
+        const depth = ++this.listDepth;
+        if (depth === this.listScratch.length)
+            this.listScratch.push([]);
+        return this.listScratch[depth];
+    }
+    /** The elements collected in `list` (the scratch array from `openList`) as an array of their exact
+     * length, or the shared empty array; empties the scratch array for the next list at its depth. */
+    closeList(list) {
+        this.listDepth--;
+        if (list.length === 0)
+            return emptyListNodes;
+        const nodes = list.slice();
+        list.length = 0;
+        return nodes;
     }
     /** The list; a missing list if `opening` is absent; undefined if an element parser returned undefined. */
     parseBracketedList(kind, element, opening, closing) {
@@ -2373,10 +2397,11 @@ export class Parser extends ScannerErrorReporter {
             ? this.parseFunctionOrConstructorTypeToError(isUnionType)
             : this.parseConstituentType(isUnionType);
         if (this.token() === operator || hasLeadingOperator) {
-            const types = [type];
+            const types = this.openList();
+            types.push(type);
             while (this.parseOptional(operator))
                 types.push(this.parseFunctionOrConstructorTypeToError(isUnionType));
-            const list = this.newNodeList(pos, this.nodePos(), types);
+            const list = this.newNodeList(pos, this.nodePos(), this.closeList(types));
             type = isUnionType ? new UnionTypeNode(list) : new IntersectionTypeNode(list);
             this.finishNode(type, pos);
         }
@@ -2985,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();
     }
@@ -3175,14 +3195,14 @@ export class Parser extends ScannerErrorReporter {
     }
     parseTemplateTypeSpans() {
         const pos = this.nodePos();
-        const list = [];
+        const list = this.openList();
         for (;;) {
             const span = this.parseTemplateTypeSpan();
             list.push(span);
             if (span.literal.kind !== 16 /* SyntaxKind.TemplateMiddle */)
                 break;
         }
-        return this.newNodeList(pos, this.nodePos(), list);
+        return this.newNodeList(pos, this.nodePos(), this.closeList(list));
     }
     parseTemplateTypeSpan() {
         const pos = this.nodePos();
@@ -3282,12 +3302,10 @@ export class Parser extends ScannerErrorReporter {
         let hasTrailingModifier = false;
         let hasStaticModifier = false;
         const pos = this.nodePos();
-        let list;
+        const list = this.openList();
         for (;;) {
             if (allowDecorators && this.token() === 59 /* SyntaxKind.AtToken */ && !hasTrailingModifier) {
                 const decorator = this.parseDecorator();
-                if (list === undefined)
-                    list = [];
                 list.push(decorator);
                 if (hasLeadingModifier)
                     hasTrailingDecorator = true;
@@ -3298,8 +3316,6 @@ export class Parser extends ScannerErrorReporter {
                     break;
                 if (modifier.kind === 125 /* SyntaxKind.StaticKeyword */)
                     hasStaticModifier = true;
-                if (list === undefined)
-                    list = [];
                 list.push(modifier);
                 if (hasTrailingDecorator)
                     hasTrailingModifier = true;
@@ -3307,7 +3323,8 @@ export class Parser extends ScannerErrorReporter {
                     hasLeadingModifier = true;
             }
         }
-        return list === undefined ? undefined : this.newModifierList(pos, this.nodePos(), list);
+        const nodes = this.closeList(list);
+        return nodes.length === 0 ? undefined : this.newModifierList(pos, this.nodePos(), nodes);
     }
     parseDecorator() {
         const pos = this.nodePos();
@@ -3941,7 +3958,7 @@ export class Parser extends ScannerErrorReporter {
         const pos = this.nodePos();
         const saveParsingContexts = this.parsingContexts;
         this.parsingContexts |= 1 << 14 /* ParsingContext.JsxChildren */;
-        const list = [];
+        const list = this.openList();
         for (;;) {
             // Like tsgo, this leaves the parser's current token unchanged.
             const currentToken = this.scanner.reScanJsxToken(true);
@@ -3957,7 +3974,7 @@ export class Parser extends ScannerErrorReporter {
                 break;
         }
         this.parsingContexts = saveParsingContexts;
-        return this.newNodeList(pos, this.nodePos(), list);
+        return this.newNodeList(pos, this.nodePos(), this.closeList(list));
     }
     parseJsxChild(openingTag, token) {
         switch (token) {
@@ -4519,14 +4536,14 @@ export class Parser extends ScannerErrorReporter {
     }
     parseTemplateSpans(isTaggedTemplate) {
         const pos = this.nodePos();
-        const list = [];
+        const list = this.openList();
         for (;;) {
             const span = this.parseTemplateSpan(isTaggedTemplate);
             list.push(span);
             if (span.literal.kind !== 16 /* SyntaxKind.TemplateMiddle */)
                 break;
         }
-        return this.newNodeList(pos, this.nodePos(), list);
+        return this.newNodeList(pos, this.nodePos(), this.closeList(list));
     }
     parseTemplateSpan(isTaggedTemplate) {
         const pos = this.nodePos();
@@ -5960,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();
 }
@@ -6012,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.7",
+  "version": "0.0.9",
   "description": "The TypeScript 7 compiler, ported to TypeScript and compiled to a native executable.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,18 +29,18 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@scriptc/threads": "0.4.1"
+    "@scriptc/threads": "0.4.2"
   },
   "engines": {
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@tsc-ts/darwin-arm64": "0.0.7",
-    "@tsc-ts/darwin-x64": "0.0.7",
-    "@tsc-ts/linux-arm64-gnu": "0.0.7",
-    "@tsc-ts/linux-arm64-musl": "0.0.7",
-    "@tsc-ts/linux-x64-gnu": "0.0.7",
-    "@tsc-ts/linux-x64-musl": "0.0.7",
-    "@tsc-ts/win32-x64-msvc": "0.0.7"
+    "@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-declaration-order.ts

@@ -37,7 +37,7 @@ import { getExportSymbolOfValueSymbolIfExported } from './checker-symbols.js';
 import { getBaseTypes, getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { getPropertyOfType } from './checker-members.js';
 import { FunctionFlags, getFunctionFlags } from './checker-utilities.js';
-import { getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
+import { declarationAt, declarationCount, type Symbol, SymbolFlags } from './symbol.js';
 
 /** Reports a block-scoped variable, class or enum resolved at `errorLocation` before its declaration. */
 export function checkResolvedBlockScopedVariable(c: Checker, resolved: Symbol, errorLocation: Node): void {
@@ -50,7 +50,8 @@ export function checkResolvedBlockScopedVariable(c: Checker, resolved: Symbol, e
   )
     return;
   let declaration: Node | undefined;
-  for (const d of getDeclarations(result)) {
+  for (let i = 0; i < declarationCount(result); i++) {
+    const d = declarationAt(result, i);
     if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === SyntaxKind.EnumDeclaration) {
       declaration = d;
       break;

package/src/compiler/checker-declared-types.ts

@@ -87,7 +87,7 @@ import { getIndexedAccessType, isGenericMappedType } from './checker-type-operat
 import { getSignatureInstantiation } from './checker-signatures.js';
 import { evaluateEnumMember, EvaluatedFlags, EvaluatedKind } from './checker-evaluator.js';
 import { checkTypeAssignableTo, isTypeIdenticalTo } from './relations.js';
-import { getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
+import { declarationAt, declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 export { getParentOfSymbol };
 
@@ -877,9 +877,12 @@ export function getMinTypeArgumentCount(c: Checker, typeParameters: readonly Typ
 
 /** Whether a type parameter is declared with a default, without resolving it. */
 function hasTypeParameterDefault(t: Type): boolean {
-  if (t.symbol === undefined) return false;
-  for (const d of getDeclarations(t.symbol))
+  const symbol = t.symbol;
+  if (symbol === undefined) return false;
+  for (let i = 0; i < declarationCount(symbol); i++) {
+    const d = declarationAt(symbol, i);
     if (d.kind === SyntaxKind.TypeParameter && (d as TypeParameterDeclaration).defaultType !== undefined) return true;
+  }
   return false;
 }
 

package/src/compiler/checker-deprecation.ts

@@ -32,7 +32,7 @@ import { entityNameToString } from './checker-expressions.js';
 import { isErrorType } from './checker-type-factory.js';
 import { getPropertyOfType } from './checker-members.js';
 import { signatureToString } from './type-printer.js';
-import { declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
+import { declarationAt, declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 /** Whether `declaration`, or the statement it belongs to, has a `@deprecated` JSDoc tag. */
 export function isDeprecatedDeclaration(declaration: Node): boolean {
@@ -56,25 +56,26 @@ function getJSDocDeprecatedTag(node: Node): Node | undefined {
  * members when all are.
  */
 export function isDeprecatedSymbol(c: Checker, symbol: Symbol): boolean {
-  const declarations = getDeclarations(symbol);
+  const count = declarationCount(symbol);
   const parentSymbol = getParentOfSymbol(c, symbol);
-  if (parentSymbol !== undefined && declarations.length > 1)
+  if (parentSymbol !== undefined && count > 1)
     return (parentSymbol.flags & SymbolFlags.Interface) !== 0
-      ? someDeprecatedDeclaration(declarations)
-      : everyDeprecatedDeclaration(declarations);
+      ? someDeprecatedDeclaration(symbol)
+      : everyDeprecatedDeclaration(symbol);
   return (
     (symbol.valueDeclaration !== undefined && isDeprecatedDeclaration(symbol.valueDeclaration)) ||
-    (declarations.length !== 0 && everyDeprecatedDeclaration(declarations))
+    (count !== 0 && everyDeprecatedDeclaration(symbol))
   );
 }
 
-function someDeprecatedDeclaration(declarations: readonly Node[]): boolean {
-  for (const d of declarations) if (isDeprecatedDeclaration(d)) return true;
+function someDeprecatedDeclaration(symbol: Symbol): boolean {
+  for (let i = 0; i < declarationCount(symbol); i++) if (isDeprecatedDeclaration(declarationAt(symbol, i))) return true;
   return false;
 }
 
-function everyDeprecatedDeclaration(declarations: readonly Node[]): boolean {
-  for (const d of declarations) if (!isDeprecatedDeclaration(d)) return false;
+function everyDeprecatedDeclaration(symbol: Symbol): boolean {
+  for (let i = 0; i < declarationCount(symbol); i++)
+    if (!isDeprecatedDeclaration(declarationAt(symbol, i))) return false;
   return true;
 }
 
@@ -330,7 +331,8 @@ export function checkDeprecatedTypeReference(c: Checker, node: Node, type: Type)
   if (isErrorType(c, type)) return;
   const symbol = c.resolvedSymbols.get(node.id);
   if (symbol === undefined) return;
-  for (const d of getDeclarations(symbol)) {
+  for (let i = 0; i < declarationCount(symbol); i++) {
+    const d = declarationAt(symbol, i);
     if (isTypeDeclaration(d) && isDeprecatedDeclaration(d)) {
       addDeprecatedSuggestion(c, getDeprecatedSuggestionNode(node), getDeclarations(symbol), symbol.name);
       return;

package/src/compiler/checker-destructuring.ts

@@ -115,7 +115,15 @@ import { TypeFacts, getNonNullableType, getTypeWithFacts, hasTypeFacts } from '.
 import { sliceTupleType } from './checker-signatures.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
 import { checkPropertyAccessibility } from './checker-property-access.js';
-import { CheckFlags, copyDeclarations, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
+import {
+  CheckFlags,
+  copyDeclarations,
+  declarationAt,
+  declarationCount,
+  getSymbolId,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 function isBindingPatternNode(node: Node | undefined): boolean {
   return (
@@ -766,7 +774,8 @@ export function isSpreadableProperty(prop: Symbol): boolean {
     (prop.flags & (SymbolFlags.Method | SymbolFlags.GetAccessor | SymbolFlags.SetAccessor)) === 0;
   let hasPrivateName = false;
   let inClass = false;
-  for (const d of getDeclarations(prop)) {
+  for (let i = 0; i < declarationCount(prop); i++) {
+    const d = declarationAt(prop, i);
     if (isPrivateIdentifierClassElementDeclaration(d)) hasPrivateName = true;
     if (d.parent !== undefined && isClassLike(d.parent)) inClass = true;
   }

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;

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

@@ -161,6 +161,40 @@ function checkSourceFileWorker(c: Checker, file: SourceFile): void {
   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: Checker, file: SourceFile, start: number, end: number): boolean {
+  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: Checker, node: Node | undefined): void {
   if (node === undefined) return;

package/src/compiler/checker-symbol-types.ts

@@ -129,7 +129,16 @@ import { getTypeForBindingElement, getTypeFromBindingPattern } from './checker-d
 import { checkRightHandSideOfForOf } from './checker-statements.js';
 import { getTypeWithFacts, TypeFacts, hasTypeFacts, getNonNullableType } from './checker-flow.js';
 import { getTypeOfModuleExportsSymbol, getWidenedTypeForAssignmentDeclaration } from './checker-javascript.js';
-import { CheckFlags, copyDeclarations, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
+import {
+  CheckFlags,
+  copyDeclarations,
+  declarationAt,
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 export function getTypeOfSymbol(c: Checker, symbol: Symbol): Type {
   const checkFlags = symbol.checkFlags;
@@ -932,12 +941,13 @@ export function isReadonlySymbol(c: Checker, symbol: Symbol): boolean {
       (getDeclarationNodeFlagsFromSymbol(symbol) & NodeFlags.Constant) !== 0) ||
     ((symbol.flags & SymbolFlags.Accessor) !== 0 && (symbol.flags & SymbolFlags.SetAccessor) === 0) ||
     (symbol.flags & SymbolFlags.EnumMember) !== 0 ||
-    someReadonlyAssignmentDeclaration(c, getDeclarations(symbol))
+    someReadonlyAssignmentDeclaration(c, symbol)
   );
 }
 
-function someReadonlyAssignmentDeclaration(c: Checker, declarations: readonly Node[]): boolean {
-  for (const d of declarations) if (isReadonlyAssignmentDeclaration(c, d)) return true;
+function someReadonlyAssignmentDeclaration(c: Checker, symbol: Symbol): boolean {
+  for (let i = 0; i < declarationCount(symbol); i++)
+    if (isReadonlyAssignmentDeclaration(c, declarationAt(symbol, i))) return true;
   return false;
 }
 

package/src/compiler/checker-symbols.ts

@@ -957,6 +957,7 @@ export function setGlobal(c: Checker, name: string, symbol: Symbol): void {
 function setMergedSymbol(c: Checker, id: number, target: Symbol): void {
   if (c.mergedSymbolChanges !== undefined) 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. */
@@ -1298,7 +1299,7 @@ function recordMergedSymbol(c: Checker, target: Symbol, source: Symbol): void {
 
 export function getMergedSymbol(c: Checker, symbol: Symbol): 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;
   }
@@ -1761,7 +1762,10 @@ export function symbolIsValue(c: Checker, symbol: Symbol): boolean {
 function isDeclarationContainedBy(symbol: Symbol, container: Symbol): boolean {
   const declaration = symbol.valueDeclaration;
   if (declaration !== undefined)
-    for (const d of getDeclarations(container)) if (declaration.pos >= d.pos && declaration.end <= d.end) return true;
+    for (let i = 0; i < declarationCount(container); i++) {
+      const d = declarationAt(container, i);
+      if (declaration.pos >= d.pos && declaration.end <= d.end) return true;
+    }
   return false;
 }