tsc-ts 0.0.6 → 0.0.8

package/src/compiler/checker-emit-helpers.ts

@@ -57,7 +57,8 @@ class PendingHelperCheck {
 export class EmitHelperFileLinks {
   helpersModule: Symbol | undefined = undefined;
   requestedHelpers: number = ExternalEmitHelpers.None;
-  pending: PendingHelperCheck[] = [];
+  /** Created on the first check; most files have none. */
+  pending: PendingHelperCheck[] | undefined = undefined;
 }
 
 function fileLinks(c: Checker, file: SourceFile): EmitHelperFileLinks {
@@ -86,7 +87,7 @@ export function checkExternalEmitHelpers(c: Checker, location: Node, helpers: Ex
     const fileIndex = c.fileIndex.get(file);
     const checkingIndex = c.fileIndex.get(checking);
     if (fileIndex !== undefined && checkingIndex !== undefined && fileIndex < checkingIndex) {
-      fileLinks(c, file).pending.push(new PendingHelperCheck(location, helpers));
+      (fileLinks(c, file).pending ??= []).push(new PendingHelperCheck(location, helpers));
       return;
     }
   }
@@ -141,9 +142,9 @@ export function checkExternalEmitHelpers(c: Checker, location: Node, helpers: Ex
 /** Runs the helper checks for nodes of `file` that were reached while checking later files. */
 export function checkPendingExternalEmitHelpers(c: Checker, file: SourceFile): void {
   const links = c.emitHelperFileLinks.get(file);
-  if (links === undefined || links.pending.length === 0) return;
+  if (links?.pending === undefined) return;
   const pending = links.pending;
-  links.pending = [];
+  links.pending = undefined;
   for (const check of pending) checkExternalEmitHelpers(c, check.location, check.helpers);
 }
 

package/src/compiler/checker-grammar.ts

@@ -80,6 +80,8 @@ import {
   getTypeArguments,
   getTypeParameters,
   isDeclarationNode,
+  callQuestionDotToken,
+  callTypeArguments,
 } from './ast.js';
 import {
   canHaveDecorators,
@@ -1297,7 +1299,7 @@ function checkGrammarDecorator(g: GrammarChecker, decorator: Decorator): boolean
       const call = node as CallExpression;
       if (!canHaveCallExpression) errorNode = node;
       // A `?.` token comes first, so it wins over an earlier error node.
-      if (call.questionDotToken !== undefined) errorNode = call.questionDotToken;
+      if (callQuestionDotToken(call) !== undefined) errorNode = callQuestionDotToken(call);
       node = call.expression;
       canHaveCallExpression = false;
       continue;
@@ -3305,7 +3307,7 @@ function checkGrammarCallExpression(g: GrammarChecker, node: CallExpression): vo
       (callee as MetaProperty).keywordToken === SyntaxKind.ImportKeyword &&
       (callee as MetaProperty).name.text === 'defer');
   if (isImportCall) checkGrammarImportCallExpression(g, node);
-  else checkGrammarTypeArguments(g, node.typeArguments);
+  else checkGrammarTypeArguments(g, callTypeArguments(node));
 }
 
 function checkGrammarImportCallExpression(g: GrammarChecker, node: CallExpression): boolean {
@@ -3331,7 +3333,7 @@ function checkGrammarImportCallExpression(g: GrammarChecker, node: CallExpressio
       node,
       Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_node18_node20_or_nodenext,
     );
-  if (node.typeArguments !== undefined)
+  if (callTypeArguments(node) !== undefined)
     return grammarErrorOnNode(
       g,
       node,

package/src/compiler/checker-inference.ts

@@ -293,20 +293,27 @@ export class IntraExpressionInferenceSite {
   }
 }
 
-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 {
+  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 = undefined;
   /** Maps to inferences from the return type, if any. */
   returnMapper: TypeMapper | undefined = undefined;
   outerReturnMapper: TypeMapper | undefined = undefined;
   inferredTypeParameters: Type[] | undefined = undefined;
-  intraExpressionInferenceSites: IntraExpressionInferenceSite[] = [];
+  /** Created on the first site; most contexts get none. */
+  intraExpressionInferenceSites: IntraExpressionInferenceSite[] | undefined = undefined;
 
   constructor(
     c: Checker,
@@ -315,45 +322,61 @@ export class InferenceContext {
     flags: InferenceFlags,
     compareTypes: TypeComparer,
   ) {
+    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 {
-  readonly c: Checker;
-  readonly context: InferenceContext;
-  readonly fixing: boolean;
+  /** Fixes inferences. */
+  get mapper(): TypeMapper {
+    return this;
+  }
 
-  constructor(c: Checker, context: InferenceContext, fixing: boolean) {
-    super();
-    this.c = c;
-    this.context = context;
-    this.fixing = fixing;
+  /** Maps to the current inferences without fixing them. */
+  get nonFixingMapper(): TypeMapper {
+    const mapper = new NonFixingInferenceMapper(this);
+    const outer = this.nonFixingOuter;
+    return outer !== undefined ? combineTypeMappers(this.c, mapper, outer) : mapper;
   }
 
   map(type: Type): 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 {
+  readonly context: InferenceContext;
+
+  constructor(context: InferenceContext) {
+    super();
+    this.context = context;
+  }
+
+  map(type: Type): 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: Checker,
   typeParameters: readonly Type[],
@@ -402,7 +425,7 @@ export function createOuterReturnMapper(c: Checker, context: InferenceContext):
 }
 
 export function addIntraExpressionInferenceSite(context: InferenceContext, node: Node, type: Type): void {
-  context.intraExpressionInferenceSites.push(new IntraExpressionInferenceSite(node, type));
+  (context.intraExpressionInferenceSites ??= []).push(new IntraExpressionInferenceSite(node, type));
 }
 
 export function clearCachedInferences(inferences: InferenceInfo[]): void {
@@ -2126,7 +2149,8 @@ export function instantiateReverseMappedType(c: Checker, t: ReverseMappedType, m
 /** Infers early from intra-expression sites (context-sensitive elements of object and array literals). */
 export function inferFromIntraExpressionSites(c: Checker, context: InferenceContext): void {
   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)
@@ -2402,7 +2426,7 @@ export function inferTypesForConditional(
   // The constraints of `infer` type parameters may refer to other roots or to what `mapper` maps,
   // so the non-fixing mapper combines with `mapper`.
   const context = createInferenceContext(c, root.inferTypeParameters, undefined, InferenceFlags.None, undefined);
-  if (mapper !== undefined) context.nonFixingMapper = combineTypeMappers(c, context.nonFixingMapper, mapper);
+  if (mapper !== undefined) context.nonFixingOuter = mapper;
   // Inferences from constraints could eagerly resolve what should defer; contravariance is always strict.
   if (!checkTypeDeferred)
     inferTypes(

package/src/compiler/checker-members.ts

@@ -1611,6 +1611,170 @@ export function getPropertyOfTypeEx(
   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 {
+  readonly positions: Map<string, number>;
+  readonly staticPrivate: number[];
+  readonly required: number[];
+
+  constructor(positions: Map<string, number>, staticPrivate: number[], required: number[]) {
+    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: Checker, target: Type, properties: Symbol[]): PropertyListIndex | undefined {
+  const known = c.propertyListIndexes.get(properties);
+  if (known instanceof PropertyListIndex) return known;
+  if (known === null) return undefined;
+  let positions: Map<string, number> | undefined;
+  const pending = (target.flags & 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<string, number>() : undefined;
+  const staticPrivate: number[] = [];
+  const required: number[] = [];
+  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 & SymbolFlags.Optional) === 0 && (p.checkFlags & 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: Checker,
+  targetProperties: Symbol[],
+  found: number[],
+  requireOptionalProperties: boolean,
+): Symbol | undefined {
+  const index = c.propertyListIndexes.get(targetProperties) as PropertyListIndex;
+  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: Checker, t: Type): Symbol[] | undefined {
+  const holder = (t.objectFlags & ObjectFlags.MembersResolved) !== 0 ? (t as StructuredType) : membersHolder(c, t);
+  if ((holder.objectFlags & 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: Checker,
+  source: Type,
+  target: Type,
+  targetProperties: Symbol[],
+): number[] | undefined {
+  if (targetProperties.length < indexedTargetPropertiesMinimum) return undefined;
+  if ((source.flags & 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 & SymbolFlags.ValueModule) !== 0) return undefined;
+  const sourceProperties = resolvedPropertiesIfAny(c, source);
+  if (sourceProperties === undefined) return undefined;
+  const resolved = membersHolder(c, source);
+  let functionType: Type | undefined;
+  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 & TypeFlags.Object) !== 0) {
+    const properties = resolvedPropertiesIfAny(c, functionType);
+    if (properties === undefined) return undefined;
+    functionProperties = properties;
+  }
+  const objectProperties =
+    (c.globalObjectType.flags & 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: number[] = [];
+  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: Checker, t: Type, name: string): Symbol | undefined {
   if ((t.flags & TypeFlags.Object) === 0) return undefined;
   const symbol = getResolvedMember(resolveStructuredTypeMembers(c, t), name);

package/src/compiler/checker-modules.ts

@@ -226,6 +226,22 @@ export function resolveExternalModuleNameWorker(
   );
 }
 
+/** A `resolveExternalModule` result that reported nothing, and the arguments it was computed for. */
+export class ModuleResolution {
+  constructor(
+    readonly moduleReference: string,
+    readonly moduleNotFoundError: DiagnosticMessage | undefined,
+    readonly isForAugmentation: boolean,
+    readonly 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 function resolveExternalModule(
   c: Checker,
   location: Node,
@@ -233,6 +249,80 @@ export function resolveExternalModule(
   moduleNotFoundError: DiagnosticMessage | undefined,
   errorNode: Node | undefined,
   isForAugmentation: boolean,
+): Symbol | undefined {
+  // 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: Node, errorNode: Node): boolean {
+  const declaration = errorNode.parent;
+  if (
+    declaration === undefined ||
+    (declaration.kind !== SyntaxKind.ImportDeclaration &&
+      declaration.kind !== SyntaxKind.JSImportDeclaration &&
+      declaration.kind !== SyntaxKind.ExportDeclaration) ||
+    getModuleSpecifier(declaration) !== errorNode
+  )
+    return false;
+  for (let current: Node | undefined = location; current !== undefined; current = current.parent)
+    switch (current.kind) {
+      case SyntaxKind.ImportDeclaration:
+      case SyntaxKind.JSImportDeclaration:
+      case SyntaxKind.ExportDeclaration:
+        return current === declaration;
+      case SyntaxKind.ImportClause:
+      case SyntaxKind.NamedImports:
+      case SyntaxKind.NamespaceImport:
+      case SyntaxKind.ImportSpecifier:
+      case SyntaxKind.NamedExports:
+      case SyntaxKind.NamespaceExport:
+      case SyntaxKind.ExportSpecifier:
+        break;
+      default:
+        if (current !== errorNode) return false;
+    }
+  return false;
+}
+
+function resolveExternalModuleWorker(
+  c: Checker,
+  location: Node,
+  moduleReference: string,
+  moduleNotFoundError: DiagnosticMessage | undefined,
+  errorNode: Node | undefined,
+  isForAugmentation: boolean,
 ): Symbol | undefined {
   if (errorNode !== undefined && moduleReference.startsWith('@types/'))
     c.error(
@@ -789,7 +879,8 @@ function isOnlyImportableAsDefault(c: Checker, usage: Node, resolvedModule: Symb
   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'))
   );
 }
 

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

@@ -1761,7 +1761,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;
 }
 

package/src/compiler/checker.ts

@@ -72,6 +72,7 @@ import {
   type TypeChecking,
 } from './checker-types.js';
 import { getBaseTypes } from './checker-declared-types.js';
+import type { ModuleResolution } from './checker-modules.js';
 import { getFalseTypeFromConditionalType, getTrueTypeFromConditionalType } from './checker-type-operators.js';
 import {
   createArrayType,
@@ -112,6 +113,7 @@ import { SourceFileMetadata, getEmitModuleFormatOfFile } from './program-utiliti
 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 abstract class CheckerHost {
@@ -345,6 +347,15 @@ export class Checker implements TypeChecking {
 
   readonly diagnostics = new DiagnosticCollection();
   readonly 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). */
+  readonly moduleResolutions = new 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 = false;
   /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
   readonly moduleSpecifiers = new Map<string, string>();
   /** Specifier generation for hosts without a program. */
@@ -359,6 +370,11 @@ export class Checker implements TypeChecking {
   readonly sideHolders = new LinkTable<Type>();
   /** The same for signatures with side state (`signatureSideOf`), by signature id. */
   readonly signatureSideHolders = new 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 = new Map<Symbol[], PropertyListIndex | number | null>();
   /** The type of a value symbol. */
   readonly symbolTypes = new LinkTable<Type>();
   /** For instantiated and synthetic symbols, the symbol they come from. */
@@ -894,6 +910,7 @@ export class Checker implements TypeChecking {
     this.diagnostics.startLog();
     this.suggestionDiagnostics.startLog();
     mergeAmbientModulesAndAugmentations(this);
+    this.modulesMerged = true;
     this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
   }
 
@@ -1026,11 +1043,13 @@ export class Checker implements TypeChecking {
   }
 
   addDiagnostic(diagnostic: Diagnostic): void {
+    this.reports++;
     // Discard diagnostics created while at the maximum number of nested typeToString calls.
     if (this.serializationLevel < maxSerializationLevel) this.diagnostics.add(diagnostic);
   }
 
   addSuggestion(diagnostic: Diagnostic): void {
+    this.reports++;
     this.suggestionDiagnostics.add(diagnostic);
   }
 

package/src/compiler/decoder.ts

@@ -13,7 +13,6 @@ import {
   BindingPattern,
   Block,
   BreakStatement,
-  CallExpression,
   CallSignatureDeclaration,
   CaseBlock,
   CaseOrDefaultClause,
@@ -149,7 +148,6 @@ import {
   PrefixUnaryExpression,
   PrivateIdentifier,
   PropertyAccessExpression,
-  PropertyAssignment,
   PropertyDeclaration,
   PropertySignatureDeclaration,
   QualifiedName,
@@ -197,6 +195,8 @@ import {
   WhileStatement,
   WithStatement,
   YieldExpression,
+  newCallExpression,
+  newPropertyAssignment,
 } from './ast.js';
 import { modifiersToFlags } from './ast-utilities.js';
 import { protocolVersion } from './encoder.js';
@@ -883,7 +883,7 @@ class Decoder {
       case SyntaxKind.ElementAccessExpression:
         return new ElementAccessExpression(this.required(0), this.token(1), this.required(2), 0);
       case SyntaxKind.CallExpression:
-        return new CallExpression(this.required(0), this.token(1), this.list(2), this.requiredList(3), 0);
+        return newCallExpression(this.required(0), this.token(1), this.list(2), this.requiredList(3), 0, false);
       case SyntaxKind.NewExpression:
         return new NewExpression(this.required(0), this.list(1), this.list(2));
       case SyntaxKind.MetaProperty:
@@ -910,12 +910,13 @@ class Decoder {
       case SyntaxKind.SpreadAssignment:
         return new SpreadAssignment(this.required(0));
       case SyntaxKind.PropertyAssignment:
-        return new PropertyAssignment(
+        return newPropertyAssignment(
           this.modifiers(0),
           this.required(1),
           this.token(2),
           this.node(3),
           this.required(4),
+          false,
         );
       case SyntaxKind.ShorthandPropertyAssignment:
         return new ShorthandPropertyAssignment(