tsc-ts 0.0.6 → 0.0.7

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

@@ -56,28 +56,38 @@ export declare class IntraExpressionInferenceSite {
     readonly type: Type;
     constructor(node: Node, type: Type);
 }
-export declare class InferenceContext {
+/**
+ * The inferences for a set of type parameters. The context is its own fixing mapper (`mapper`), and
+ * each read of `nonFixingMapper` returns a new mapper that reads the context: no mapper the context
+ * holds refers back to it, so a context whose inference is done is freed by reference counting
+ * rather than by the cycle collector.
+ */
+export declare class InferenceContext extends TypeMapper {
+    readonly c: Checker;
     inferences: InferenceInfo[];
     /** The generic signature inferences are made for, if any. */
     readonly signature: Signature | undefined;
     flags: InferenceFlags;
     readonly compareTypes: TypeComparer;
-    /** Fixes inferences. */
-    mapper: TypeMapper;
-    nonFixingMapper: TypeMapper;
+    /** Combined after the non-fixing mapper (conditional types' `infer` constraints), if any. */
+    nonFixingOuter: TypeMapper | undefined;
     /** Maps to inferences from the return type, if any. */
     returnMapper: TypeMapper | undefined;
     outerReturnMapper: TypeMapper | undefined;
     inferredTypeParameters: Type[] | undefined;
-    intraExpressionInferenceSites: IntraExpressionInferenceSite[];
+    /** Created on the first site; most contexts get none. */
+    intraExpressionInferenceSites: IntraExpressionInferenceSite[] | undefined;
     constructor(c: Checker, inferences: InferenceInfo[], signature: Signature | undefined, flags: InferenceFlags, compareTypes: TypeComparer);
+    /** Fixes inferences. */
+    get mapper(): TypeMapper;
+    /** Maps to the current inferences without fixing them. */
+    get nonFixingMapper(): TypeMapper;
+    map(type: Type): Type;
 }
-/** Maps a context's type parameters to their inferred types, optionally fixing them. */
-export declare class InferenceTypeMapper extends TypeMapper {
-    readonly c: Checker;
+/** Maps a context's type parameters to their inferred types without fixing them. */
+export declare class NonFixingInferenceMapper extends TypeMapper {
     readonly context: InferenceContext;
-    readonly fixing: boolean;
-    constructor(c: Checker, context: InferenceContext, fixing: boolean);
+    constructor(context: InferenceContext);
     map(type: Type): Type;
 }
 export declare function createInferenceContext(c: Checker, typeParameters: readonly Type[], signature: Signature | undefined, flags: InferenceFlags, compareTypes: TypeComparer | undefined): InferenceContext;

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

@@ -61,57 +61,78 @@ export class IntraExpressionInferenceSite {
         this.type = type;
     }
 }
-export class InferenceContext {
+/**
+ * The inferences for a set of type parameters. The context is its own fixing mapper (`mapper`), and
+ * each read of `nonFixingMapper` returns a new mapper that reads the context: no mapper the context
+ * holds refers back to it, so a context whose inference is done is freed by reference counting
+ * rather than by the cycle collector.
+ */
+export class InferenceContext extends TypeMapper {
+    c;
     inferences;
     /** The generic signature inferences are made for, if any. */
     signature;
     flags;
     compareTypes;
-    /** Fixes inferences. */
-    mapper;
-    nonFixingMapper;
+    /** Combined after the non-fixing mapper (conditional types' `infer` constraints), if any. */
+    nonFixingOuter = undefined;
     /** Maps to inferences from the return type, if any. */
     returnMapper = undefined;
     outerReturnMapper = undefined;
     inferredTypeParameters = undefined;
-    intraExpressionInferenceSites = [];
+    /** Created on the first site; most contexts get none. */
+    intraExpressionInferenceSites = undefined;
     constructor(c, inferences, signature, flags, compareTypes) {
+        super();
+        this.c = c;
         this.inferences = inferences;
         this.signature = signature;
         this.flags = flags;
         this.compareTypes = compareTypes;
-        this.mapper = new InferenceTypeMapper(c, this, true);
-        this.nonFixingMapper = new InferenceTypeMapper(c, this, false);
     }
-}
-/** Maps a context's type parameters to their inferred types, optionally fixing them. */
-export class InferenceTypeMapper extends TypeMapper {
-    c;
-    context;
-    fixing;
-    constructor(c, context, fixing) {
-        super();
-        this.c = c;
-        this.context = context;
-        this.fixing = fixing;
+    /** Fixes inferences. */
+    get mapper() {
+        return this;
+    }
+    /** Maps to the current inferences without fixing them. */
+    get nonFixingMapper() {
+        const mapper = new NonFixingInferenceMapper(this);
+        const outer = this.nonFixingOuter;
+        return outer !== undefined ? combineTypeMappers(this.c, mapper, outer) : mapper;
     }
     map(type) {
-        const inferences = this.context.inferences;
+        const inferences = this.inferences;
         for (let i = 0; i < inferences.length; i++) {
             const inference = inferences[i];
             if (type !== inference.typeParameter)
                 continue;
-            if (this.fixing && !inference.isFixed) {
+            if (!inference.isFixed) {
                 // Infer from intra-expression sites before committing to an inference.
-                inferFromIntraExpressionSites(this.c, this.context);
+                inferFromIntraExpressionSites(this.c, this);
                 clearCachedInferences(inferences);
                 inference.isFixed = true;
             }
-            return getInferredType(this.c, this.context, i);
+            return getInferredType(this.c, this, i);
         }
         return type;
     }
 }
+/** Maps a context's type parameters to their inferred types without fixing them. */
+export class NonFixingInferenceMapper extends TypeMapper {
+    context;
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    map(type) {
+        const context = this.context;
+        const inferences = context.inferences;
+        for (let i = 0; i < inferences.length; i++)
+            if (type === inferences[i].typeParameter)
+                return getInferredType(context.c, context, i);
+        return type;
+    }
+}
 export function createInferenceContext(c, typeParameters, signature, flags, compareTypes) {
     const inferences = [];
     for (const tp of typeParameters)
@@ -144,7 +165,7 @@ export function createOuterReturnMapper(c, context) {
     return context.outerReturnMapper;
 }
 export function addIntraExpressionInferenceSite(context, node, type) {
-    context.intraExpressionInferenceSites.push(new IntraExpressionInferenceSite(node, type));
+    (context.intraExpressionInferenceSites ??= []).push(new IntraExpressionInferenceSite(node, type));
 }
 export function clearCachedInferences(inferences) {
     for (const inference of inferences)
@@ -1678,7 +1699,9 @@ export function instantiateReverseMappedType(c, t, mapper) {
 /** Infers early from intra-expression sites (context-sensitive elements of object and array literals). */
 export function inferFromIntraExpressionSites(c, context) {
     const sites = context.intraExpressionInferenceSites;
-    context.intraExpressionInferenceSites = [];
+    if (sites === undefined)
+        return;
+    context.intraExpressionInferenceSites = undefined;
     for (const site of sites) {
         const contextualType = getContextualTypeForInference(c, site.node);
         if (contextualType !== undefined)
@@ -1940,7 +1963,7 @@ export function inferTypesForConditional(c, root, checkType, extendsType, mapper
     // so the non-fixing mapper combines with `mapper`.
     const context = createInferenceContext(c, root.inferTypeParameters, undefined, 0 /* InferenceFlags.None */, undefined);
     if (mapper !== undefined)
-        context.nonFixingMapper = combineTypeMappers(c, context.nonFixingMapper, mapper);
+        context.nonFixingOuter = mapper;
     // Inferences from constraints could eagerly resolve what should defer; contravariance is always strict.
     if (!checkTypeDeferred)
         inferTypes(c, context.inferences, checkType, extendsType, 512 /* InferencePriority.NoConstraints */ | 1024 /* InferencePriority.AlwaysStrict */, false);

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

@@ -142,6 +142,33 @@ export declare function getPropertyOfType(c: Checker, t: Type, name: string): Sy
  * primitives and type parameters, and falls back to Object and Function members.
  */
 export declare function getPropertyOfTypeEx(c: Checker, t: Type, name: string, skipObjectFunctionPropertyAugment: boolean, includeTypeOnlyMembers: boolean): Symbol | undefined;
+/**
+ * A long property list that `propertiesRelatedTo` walks: the position of each name, and the positions of
+ * the static private properties, which `getUnmatchedProperty` never reports, and of the required ones.
+ */
+export declare class PropertyListIndex {
+    readonly positions: Map<string, number>;
+    readonly staticPrivate: number[];
+    readonly required: number[];
+    constructor(positions: Map<string, number>, staticPrivate: number[], required: number[]);
+}
+/**
+ * `getUnmatchedProperty(c, source, target, requireOptionalProperties, false)` where `targetProperties` are
+ * the target's properties and `found` the positions of the names the source has
+ * (`positionsOfNamesFoundInSource`): the first property that is not static private, and is required unless
+ * `requireOptionalProperties`, at a position not in `found`.
+ */
+export declare function firstUnmatchedProperty(c: Checker, targetProperties: Symbol[], found: number[], requireOptionalProperties: boolean): Symbol | undefined;
+/**
+ * The positions in `targetProperties`, the properties of `target`, ascending, of the names
+ * `getPropertyOfType(c, source, name)` finds: the names of the source's properties and of the Function and
+ * Object members its lookups fall back to. `getPropertyOfType` answers undefined for the names at every
+ * other position. Undefined where the answer cannot be read from resolved property lists without resolving
+ * anything (not an object type, an apparent type, members not resolved or not instantiated yet, a module),
+ * where the target list is too short or the source list too long to save lookups, and where the target
+ * list has no index (yet: `propertyListIndex`).
+ */
+export declare function positionsOfNamesFoundInSource(c: Checker, source: Type, target: Type, targetProperties: Symbol[]): number[] | undefined;
 export declare function getPropertyOfObjectType(c: Checker, t: Type, name: string): Symbol | undefined;
 export declare function getTypeOfPropertyOfType(c: Checker, t: Type, name: string): Type | undefined;
 export declare function getPropertyOfUnionOrIntersectionType(c: Checker, t: UnionOrIntersectionType, name: string, skipObjectFunctionPropertyAugment: boolean): Symbol | undefined;

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

@@ -1305,6 +1305,171 @@ export function getPropertyOfTypeEx(c, t, name, skipObjectFunctionPropertyAugmen
         return getPropertyOfUnionOrIntersectionType(c, t, name, skipObjectFunctionPropertyAugment);
     return undefined;
 }
+/**
+ * A long property list that `propertiesRelatedTo` walks: the position of each name, and the positions of
+ * the static private properties, which `getUnmatchedProperty` never reports, and of the required ones.
+ */
+export class PropertyListIndex {
+    positions;
+    staticPrivate;
+    required;
+    constructor(positions, staticPrivate, required) {
+        this.positions = positions;
+        this.staticPrivate = staticPrivate;
+        this.required = required;
+    }
+}
+/** The uses of a long property list after which `propertyListIndex` indexes it by a table of its own. */
+const propertyListUsesBeforeIndex = 3;
+/**
+ * The index of `properties`, the properties of `target`. Where the members of `target` are properties
+ * with shared names (`PropertyMembers` with `MemberNames`), the index reads the positions of those names.
+ * Other lists get a positions table of their own on the use after the first `propertyListUsesBeforeIndex`:
+ * most long lists are related only a few times, and the lists related many times hold most of the lookups
+ * the index saves. Undefined before that, and where the list repeats a name.
+ */
+function propertyListIndex(c, target, properties) {
+    const known = c.propertyListIndexes.get(properties);
+    if (known instanceof PropertyListIndex)
+        return known;
+    if (known === null)
+        return undefined;
+    let positions;
+    const pending = (target.flags & 1048576 /* TypeFlags.Object */) !== 0 ? membersHolder(c, target).pendingMembers : undefined;
+    if (pending instanceof PropertyMembers &&
+        pending.materializedProperties === properties &&
+        pending.names !== undefined) {
+        // The names are the names of the properties, in order (hasMemberNames).
+        positions = pending.names.positions;
+        if (positions.size !== properties.length) {
+            c.propertyListIndexes.set(properties, null);
+            return undefined;
+        }
+    }
+    else {
+        const uses = known ?? 0;
+        if (uses < propertyListUsesBeforeIndex) {
+            c.propertyListIndexes.set(properties, uses + 1);
+            return undefined;
+        }
+    }
+    const own = positions === undefined ? new Map() : undefined;
+    const staticPrivate = [];
+    const required = [];
+    for (let i = 0; i < properties.length; i++) {
+        const p = properties[i];
+        if (own !== undefined) {
+            if (own.has(p.name)) {
+                c.propertyListIndexes.set(properties, null);
+                return undefined;
+            }
+            own.set(p.name, i);
+        }
+        if (isStaticPrivateIdentifierProperty(p))
+            staticPrivate.push(i);
+        else if ((p.flags & 16777216 /* SymbolFlags.Optional */) === 0 && (p.checkFlags & 48 /* CheckFlags.Partial */) === 0)
+            required.push(i);
+    }
+    const index = new PropertyListIndex((positions ?? own), staticPrivate, required);
+    c.propertyListIndexes.set(properties, index);
+    return index;
+}
+/**
+ * `getUnmatchedProperty(c, source, target, requireOptionalProperties, false)` where `targetProperties` are
+ * the target's properties and `found` the positions of the names the source has
+ * (`positionsOfNamesFoundInSource`): the first property that is not static private, and is required unless
+ * `requireOptionalProperties`, at a position not in `found`.
+ */
+export function firstUnmatchedProperty(c, targetProperties, found, requireOptionalProperties) {
+    const index = c.propertyListIndexes.get(targetProperties);
+    let next = 0;
+    if (!requireOptionalProperties) {
+        for (const position of index.required) {
+            while (next < found.length && found[next] < position)
+                next++;
+            if (next === found.length || found[next] !== position)
+                return targetProperties[position];
+        }
+        return undefined;
+    }
+    const staticPrivate = index.staticPrivate;
+    let nextPrivate = 0;
+    for (let position = 0; position < targetProperties.length; position++) {
+        // A position can be both found and static private: both lists move past it.
+        const isFound = next < found.length && found[next] === position;
+        if (isFound)
+            next++;
+        const isStaticPrivate = nextPrivate < staticPrivate.length && staticPrivate[nextPrivate] === position;
+        if (isStaticPrivate)
+            nextPrivate++;
+        if (!isFound && !isStaticPrivate)
+            return targetProperties[position];
+    }
+    return undefined;
+}
+/** The shortest target property list that `positionsOfNamesFoundInSource` indexes. */
+const indexedTargetPropertiesMinimum = 32;
+/** The properties of `t` where its members are resolved and instantiated, else undefined. */
+function resolvedPropertiesIfAny(c, t) {
+    const holder = (t.objectFlags & 2097152 /* ObjectFlags.MembersResolved */) !== 0 ? t : membersHolder(c, t);
+    if ((holder.objectFlags & 2097152 /* ObjectFlags.MembersResolved */) === 0)
+        return undefined;
+    const pending = holder.pendingMembers;
+    return pending === undefined || pending.materializedProperties !== undefined ? holder.properties : undefined;
+}
+/**
+ * The positions in `targetProperties`, the properties of `target`, ascending, of the names
+ * `getPropertyOfType(c, source, name)` finds: the names of the source's properties and of the Function and
+ * Object members its lookups fall back to. `getPropertyOfType` answers undefined for the names at every
+ * other position. Undefined where the answer cannot be read from resolved property lists without resolving
+ * anything (not an object type, an apparent type, members not resolved or not instantiated yet, a module),
+ * where the target list is too short or the source list too long to save lookups, and where the target
+ * list has no index (yet: `propertyListIndex`).
+ */
+export function positionsOfNamesFoundInSource(c, source, target, targetProperties) {
+    if (targetProperties.length < indexedTargetPropertiesMinimum)
+        return undefined;
+    if ((source.flags & 1048576 /* TypeFlags.Object */) === 0 || !isOwnReducedApparentType(source))
+        return undefined;
+    // A module's member that only an `export type *` declaration exports is not found.
+    if (source.symbol !== undefined && (source.symbol.flags & 512 /* SymbolFlags.ValueModule */) !== 0)
+        return undefined;
+    const sourceProperties = resolvedPropertiesIfAny(c, source);
+    if (sourceProperties === undefined)
+        return undefined;
+    const resolved = membersHolder(c, source);
+    let functionType;
+    if (source === c.anyFunctionType)
+        functionType = c.globalFunctionType;
+    else if (resolved.callSignatures.length !== 0)
+        functionType = c.globalCallableFunctionType;
+    else if (resolved.constructSignatures.length !== 0)
+        functionType = c.globalNewableFunctionType;
+    let functionProperties = emptySymbols;
+    if (functionType !== undefined && (functionType.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+        const properties = resolvedPropertiesIfAny(c, functionType);
+        if (properties === undefined)
+            return undefined;
+        functionProperties = properties;
+    }
+    const objectProperties = (c.globalObjectType.flags & 1048576 /* TypeFlags.Object */) !== 0 ? resolvedPropertiesIfAny(c, c.globalObjectType) : emptySymbols;
+    if (objectProperties === undefined)
+        return undefined;
+    if ((sourceProperties.length + functionProperties.length + objectProperties.length) * 4 > targetProperties.length)
+        return undefined;
+    const index = propertyListIndex(c, target, targetProperties);
+    if (index === undefined)
+        return undefined;
+    const positions = index.positions;
+    const found = [];
+    for (const list of [sourceProperties, functionProperties, objectProperties])
+        for (const p of list) {
+            const position = positions.get(p.name);
+            if (position !== undefined && !found.includes(position))
+                found.push(position);
+        }
+    return found.sort((a, b) => a - b);
+}
 export function getPropertyOfObjectType(c, t, name) {
     if ((t.flags & 1048576 /* TypeFlags.Object */) === 0)
         return undefined;

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

@@ -7,6 +7,20 @@ import { type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 /** The module symbol `moduleReference` names, reporting it when it isn't found unless `ignoreErrors`. */
 export declare function resolveExternalModuleName(c: Checker, location: Node, moduleReference: Node | undefined, ignoreErrors: boolean): Symbol | undefined;
 export declare function resolveExternalModuleNameWorker(c: Checker, location: Node, moduleReference: Node | undefined, moduleNotFoundError: DiagnosticMessage | undefined, ignoreErrors: boolean, isForAugmentation: boolean): Symbol | undefined;
+/** A `resolveExternalModule` result that reported nothing, and the arguments it was computed for. */
+export declare class ModuleResolution {
+    readonly moduleReference: string;
+    readonly moduleNotFoundError: DiagnosticMessage | undefined;
+    readonly isForAugmentation: boolean;
+    readonly symbol: Symbol | undefined;
+    constructor(moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, isForAugmentation: boolean, symbol: Symbol | undefined);
+}
+/**
+ * The module symbol `moduleReference` resolves to from `location`, reporting resolution errors at
+ * `errorNode`. Each name an import or export declaration lists resolves its module specifier again,
+ * with the same result and the same diagnostics: a result that reported nothing is kept for the
+ * specifier and returned to later calls from the same declaration (`sharesSpecifierContext`).
+ */
 export declare function resolveExternalModule(c: Checker, location: Node, moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, errorNode: Node | undefined, isForAugmentation: boolean): Symbol | undefined;
 /** A message with its arguments, the elaboration of a diagnostic before it has a location. */
 export declare class DiagnosticDetails {

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

@@ -57,7 +57,78 @@ export function resolveExternalModuleNameWorker(c, location, moduleReference, mo
         return undefined;
     return resolveExternalModule(c, location, getText(moduleReference), moduleNotFoundError, ignoreErrors ? undefined : moduleReference, isForAugmentation);
 }
+/** A `resolveExternalModule` result that reported nothing, and the arguments it was computed for. */
+export class ModuleResolution {
+    moduleReference;
+    moduleNotFoundError;
+    isForAugmentation;
+    symbol;
+    constructor(moduleReference, moduleNotFoundError, isForAugmentation, symbol) {
+        this.moduleReference = moduleReference;
+        this.moduleNotFoundError = moduleNotFoundError;
+        this.isForAugmentation = isForAugmentation;
+        this.symbol = symbol;
+    }
+}
+/**
+ * The module symbol `moduleReference` resolves to from `location`, reporting resolution errors at
+ * `errorNode`. Each name an import or export declaration lists resolves its module specifier again,
+ * with the same result and the same diagnostics: a result that reported nothing is kept for the
+ * specifier and returned to later calls from the same declaration (`sharesSpecifierContext`).
+ */
 export function resolveExternalModule(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
+    // An augmentation merged later can give the resolved module a new merged symbol, so results are
+    // kept only once every augmentation is merged.
+    const shared = c.modulesMerged && errorNode !== undefined && sharesSpecifierContext(location, errorNode);
+    if (shared) {
+        const known = c.moduleResolutions.get(errorNode);
+        if (known !== undefined &&
+            known.moduleReference === moduleReference &&
+            known.moduleNotFoundError === moduleNotFoundError &&
+            known.isForAugmentation === isForAugmentation)
+            return known.symbol;
+    }
+    const reports = c.reports;
+    const symbol = resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation);
+    if (shared && c.reports === reports)
+        c.moduleResolutions.set(errorNode, new ModuleResolution(moduleReference, moduleNotFoundError, isForAugmentation, symbol));
+    return symbol;
+}
+/**
+ * Whether a resolution from `location` with errors at `errorNode` depends on `location` only through
+ * the declaration that `errorNode` is the module specifier of: `location` is that declaration, a
+ * clause or specifier inside it, or the specifier itself. The resolution mode, the emittability of
+ * the import and its resolution-mode attributes then all come from that declaration.
+ */
+function sharesSpecifierContext(location, errorNode) {
+    const declaration = errorNode.parent;
+    if (declaration === undefined ||
+        (declaration.kind !== 273 /* SyntaxKind.ImportDeclaration */ &&
+            declaration.kind !== 346 /* SyntaxKind.JSImportDeclaration */ &&
+            declaration.kind !== 279 /* SyntaxKind.ExportDeclaration */) ||
+        getModuleSpecifier(declaration) !== errorNode)
+        return false;
+    for (let current = location; current !== undefined; current = current.parent)
+        switch (current.kind) {
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                return current === declaration;
+            case 274 /* SyntaxKind.ImportClause */:
+            case 276 /* SyntaxKind.NamedImports */:
+            case 275 /* SyntaxKind.NamespaceImport */:
+            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 280 /* SyntaxKind.NamedExports */:
+            case 281 /* SyntaxKind.NamespaceExport */:
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                break;
+            default:
+                if (current !== errorNode)
+                    return false;
+        }
+    return false;
+}
+function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
     if (errorNode !== undefined && moduleReference.startsWith('@types/'))
         c.error(errorNode, 1302 /* Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1 */, moduleReference.substring(7), moduleReference);
     const ambient = tryFindAmbientModule(c, moduleReference, true);
@@ -490,7 +561,8 @@ function isOnlyImportableAsDefault(c, usage, resolvedModule) {
     const moduleSymbol = resolvedModule ?? resolveExternalModuleName(c, usage, usage, true);
     const targetFile = moduleSymbol !== undefined ? getSourceFileOfModuleSymbol(moduleSymbol) : undefined;
     return (targetFile !== undefined &&
-        (isJsonSourceFile(targetFile) || getDeclarationFileExtension(targetFile.fileName) === '.d.json.ts'));
+        (isJsonSourceFile(targetFile) ||
+            (targetFile.fileName.endsWith('.d.json.ts') && getDeclarationFileExtension(targetFile.fileName) === '.d.json.ts')));
 }
 /** The source file that declares a module: its value declaration, or its first declaration that is not an augmentation. */
 function getSourceFileOfModuleSymbol(symbol) {

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

@@ -6,6 +6,7 @@ import { Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.j
 import { type CompilerOptions, ModuleKind, ScriptTarget } from './options.js';
 import { CheckFlags, Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 import { IndexInfo, IntrinsicType, LiteralType, MemberNames, NodeLinks, ObjectFlags, ObjectType, Signature, SignatureFlags, SymbolLinks, type Type, TypeFlags, TypeMapper, TypeParameter, TypePredicate, VarianceFlags, TypeListCache, TypeListTable, type ConditionalType, type InterfaceType, type TypeChecking } from './checker-types.js';
+import type { ModuleResolution } from './checker-modules.js';
 import { CheckerNameResolver, type LibGlobals, type MergedGlobals, TableChanges, SuggestionNameResolver } from './checker-symbols.js';
 import { Relation, RelationKey, type InternedRelationKey, type Relater, TypeComparer } from './relations.js';
 import { TypeNodeVisitor } from './checker-source-file.js';
@@ -19,6 +20,7 @@ import { SourceFileMetadata } from './program-utilities.js';
 import type { GrammarChecker } from './checker-grammar.js';
 import type { ResolvedModule } from './module-resolution-types.js';
 import type { ModuleSpecifierHost } from './module-specifiers.js';
+import type { PropertyListIndex } from './checker-members.js';
 /** What the checker needs from a program. */
 export declare abstract class CheckerHost {
     abstract getCompilerOptions(): CompilerOptions;
@@ -151,6 +153,15 @@ export declare class Checker implements TypeChecking {
     currentNode: Node | undefined;
     readonly diagnostics: DiagnosticCollection;
     readonly suggestionDiagnostics: DiagnosticCollection;
+    /** Diagnostics and suggestions reported so far, whether kept or not (`resolveExternalModule`'s cache). */
+    reports: number;
+    /** `resolveExternalModule` results that reported nothing, by module specifier (checker-modules.ts). */
+    readonly moduleResolutions: Map<Node, ModuleResolution>;
+    /**
+     * Whether ambient modules and module augmentations are merged. Merging can give a module a new
+     * merged symbol, so `resolveExternalModule` keeps results only from then on.
+     */
+    modulesMerged: boolean;
     /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
     readonly moduleSpecifiers: Map<string, string>;
     /** Specifier generation for hosts without a program. */
@@ -161,6 +172,11 @@ export declare class Checker implements TypeChecking {
     readonly sideHolders: LinkTable<Type>;
     /** The same for signatures with side state (`signatureSideOf`), by signature id. */
     readonly signatureSideHolders: LinkTable<Signature>;
+    /**
+     * The indexes of long property lists that `propertiesRelatedTo` walks; before a list is indexed, its uses
+     * so far; null where a list repeats a name.
+     */
+    readonly propertyListIndexes: Map<Symbol[], number | PropertyListIndex | null>;
     /** The type of a value symbol. */
     readonly symbolTypes: LinkTable<Type>;
     /** For instantiated and synthetic symbols, the symbol they come from. */

package/dist/api/compiler/checker.js

@@ -230,6 +230,15 @@ export class Checker {
     currentNode = undefined;
     diagnostics = new DiagnosticCollection();
     suggestionDiagnostics = new DiagnosticCollection();
+    /** Diagnostics and suggestions reported so far, whether kept or not (`resolveExternalModule`'s cache). */
+    reports = 0;
+    /** `resolveExternalModule` results that reported nothing, by module specifier (checker-modules.ts). */
+    moduleResolutions = new Map();
+    /**
+     * Whether ambient modules and module augmentations are merged. Merging can give a module a new
+     * merged symbol, so `resolveExternalModule` keeps results only from then on.
+     */
+    modulesMerged = false;
     /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
     moduleSpecifiers = new Map();
     /** Specifier generation for hosts without a program. */
@@ -243,6 +252,11 @@ export class Checker {
     sideHolders = new LinkTable();
     /** The same for signatures with side state (`signatureSideOf`), by signature id. */
     signatureSideHolders = new LinkTable();
+    /**
+     * The indexes of long property lists that `propertiesRelatedTo` walks; before a list is indexed, its uses
+     * so far; null where a list repeats a name.
+     */
+    propertyListIndexes = new Map();
     /** The type of a value symbol. */
     symbolTypes = new LinkTable();
     /** For instantiated and synthetic symbols, the symbol they come from. */
@@ -740,6 +754,7 @@ export class Checker {
         this.diagnostics.startLog();
         this.suggestionDiagnostics.startLog();
         mergeAmbientModulesAndAugmentations(this);
+        this.modulesMerged = true;
         this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
     }
     // ---- Public API
@@ -830,11 +845,13 @@ export class Checker {
         return diagnostic;
     }
     addDiagnostic(diagnostic) {
+        this.reports++;
         // Discard diagnostics created while at the maximum number of nested typeToString calls.
         if (this.serializationLevel < maxSerializationLevel)
             this.diagnostics.add(diagnostic);
     }
     addSuggestion(diagnostic) {
+        this.reports++;
         this.suggestionDiagnostics.add(diagnostic);
     }
     /** Reports an error, or a suggestion when `isError` is false. */

package/dist/api/compiler/diagnostics.js

@@ -152,12 +152,14 @@ function threadCopyOf(file) {
     }
     return copy;
 }
+/** The empty value of a file's position tables until they are computed. */
+const noNumbers = [];
 /** The text of a file diagnostics point into. */
 export class DiagnosticFile {
     fileName;
     text;
     // Computed on first use; never empty once computed.
-    lineStarts = [];
+    lineStarts = noNumbers;
     /** Whether this is a thread's copy of a possibly shared file (`threadCopyOf`). */
     isThreadCopy = false;
     constructor(fileName, text) {
@@ -186,8 +188,8 @@ export class DiagnosticFile {
     // The non-ASCII characters, in order: their UTF-16 offsets, UTF-8 lengths, and the UTF-8 bytes
     // beyond one per UTF-16 code unit of the text up to and including each. Unset until first used.
     nonASCIIStarts = undefined;
-    nonASCIILengths = [];
-    extraBytes = [];
+    nonASCIILengths = noNumbers;
+    extraBytes = noNumbers;
     getNonASCIIStarts() {
         let starts = this.nonASCIIStarts;
         if (starts === undefined) {
@@ -196,8 +198,8 @@ export class DiagnosticFile {
             if (Buffer.byteLength(text, 'utf8') !== text.length) {
                 // Scanning the UTF-8 encoding is faster than reading each code unit.
                 const bytes = Buffer.from(text, 'utf8');
-                const lengths = this.nonASCIILengths;
-                const extraBytes = this.extraBytes;
+                const lengths = [];
+                const extraBytes = [];
                 let extra = 0;
                 for (let i = 0; i < bytes.length; i++) {
                     const b = bytes[i];
@@ -211,6 +213,8 @@ export class DiagnosticFile {
                     extraBytes.push(extra);
                     i += length - 1;
                 }
+                this.nonASCIILengths = lengths;
+                this.extraBytes = extraBytes;
             }
             this.nonASCIIStarts = starts;
         }

package/dist/api/compiler/parallel-parse.js

@@ -445,7 +445,9 @@ export class ParseSession {
             this.onIdle(batch);
     }
     post(i, chunk) {
-        this.workers[i].postMessage(chunk);
+        // Published, the chunk reaches the thread by pointer: copying its names into the message took the
+        // main thread 25-45 us per chunk, which during config read delays the matching of root files.
+        this.workers[i].postMessage(publish(chunk));
         this.outstanding[i] = this.outstanding[i] + 1;
         if (chunk.kinds[0] === 2 /* LoadKind.Library */ && largeLibraries.has(chunk.names[0]))
             this.blocked[i] = true;