tsc-ts 0.0.5 → 0.0.7

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

@@ -18,6 +18,7 @@ import { createPromiseType } from './checker-iteration.js';
 import { getFunctionFlags } from './checker-utilities.js';
 import { typeToString } from './type-printer.js';
 import { elaborateJsxComponents } from './checker-jsx.js';
+import { declarationCount } from './symbol.js';
 /** Checks that `source` relates to `target`, elaborating into `expr` when possible. */
 export function checkTypeRelatedToAndOptionallyElaborate(c, source, target, relation, errorNode, expr, headMessage, diagnosticOutput) {
     if (isTypeRelatedTo(c, source, target, relation))
@@ -221,11 +222,11 @@ export function elaborateElement(c, source, target, relation, prop, next, nameTy
         }
     }
     if (!issuedElaboration &&
-        ((targetProp !== undefined && targetProp.declarations.length !== 0) ||
-            (target.symbol !== undefined && target.symbol.declarations.length !== 0))) {
-        const targetNode = targetProp !== undefined && targetProp.declarations.length !== 0
-            ? targetProp.declarations[0]
-            : target.symbol.declarations[0];
+        ((targetProp !== undefined && declarationCount(targetProp) !== 0) ||
+            (target.symbol !== undefined && declarationCount(target.symbol) !== 0))) {
+        const targetNode = targetProp !== undefined && declarationCount(targetProp) !== 0
+            ? targetProp.declaration
+            : target.symbol.declaration;
         if (propertyName === '' || (nameType.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
             propertyName = typeToString(c, nameType);
         if (!c.host.isSourceFileDefaultLibrary(getSourceFileOfNode(targetNode)))
@@ -279,8 +280,8 @@ function elaborateArrowFunction(c, node, source, target, relation, diagnosticOut
     if (diagnostics.length === 0)
         return false;
     const diagnostic = diagnostics[0];
-    if (target.symbol !== undefined && target.symbol.declarations.length !== 0)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(target.symbol.declarations[0], 1517 /* Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature */, []));
+    if (target.symbol !== undefined && declarationCount(target.symbol) !== 0)
+        diagnostic.addRelatedInfo(createDiagnosticForNode(target.symbol.declaration, 1517 /* Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature */, []));
     if ((getFunctionFlags(node) & 2 /* FunctionFlags.Async */) === 0 &&
         getTypeOfPropertyOfType(c, sourceReturn, 'then') === undefined &&
         checkTypeRelatedTo(c, createPromiseType(c, sourceReturn), targetReturn, relation, undefined, undefined, undefined))

package/dist/api/compiler/checker-emit-helpers.d.ts

@@ -45,7 +45,8 @@ declare class PendingHelperCheck {
 export declare class EmitHelperFileLinks {
     helpersModule: Symbol | undefined;
     requestedHelpers: number;
-    pending: PendingHelperCheck[];
+    /** Created on the first check; most files have none. */
+    pending: PendingHelperCheck[] | undefined;
 }
 /**
  * Under --importHelpers, the emit of the syntax at `location` calls `helpers` from tslib. Reports TS2354 when

package/dist/api/compiler/checker-emit-helpers.js

@@ -16,7 +16,8 @@ class PendingHelperCheck {
 export class EmitHelperFileLinks {
     helpersModule = undefined;
     requestedHelpers = 0 /* ExternalEmitHelpers.None */;
-    pending = [];
+    /** Created on the first check; most files have none. */
+    pending = undefined;
 }
 function fileLinks(c, file) {
     let links = c.emitHelperFileLinks.get(file);
@@ -45,7 +46,7 @@ export function checkExternalEmitHelpers(c, location, helpers) {
         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;
         }
     }
@@ -78,10 +79,10 @@ export function checkExternalEmitHelpers(c, location, helpers) {
 /** Runs the helper checks for nodes of `file` that were reached while checking later files. */
 export function checkPendingExternalEmitHelpers(c, file) {
     const links = c.emitHelperFileLinks.get(file);
-    if (links === undefined || links.pending.length === 0)
+    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/dist/api/compiler/checker-emit-resolver.d.ts

@@ -2,12 +2,12 @@ import { type EntityName, type FileReference, type Identifier, type ImportDeclar
 import type { Checker } from './checker.js';
 import type { CompilerOptions, ModuleKind } from './options.js';
 import type { EmitContext } from './printer/emit-context.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { DeclarationEmitResolver, NodeBuilderFlags, type SymbolAccessibilityResult, type SymbolTracker } from './transformers/declarations-resolver.js';
 import type { SyntacticDeclarationEmitResolver } from './transformers/declarations-syntactic.js';
 import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
 import type { Evaluation, ReferenceResolver } from './transformers/reference-resolver.js';
 import { TypeReferenceSerializationKind } from './transformers/type-serialization.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
 export declare class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     readonly checker: Checker;
     /** Answers the queries that don't need types. */

package/dist/api/compiler/checker-emit-resolver.js

@@ -25,6 +25,7 @@ import { isTypeIdenticalTo } from './relations.js';
 import { beginDeclarationEmitVisibility, isDeclarationVisible, isSymbolAccessible, markDeclarationVisible, } from './symbol-accessibility.js';
 import { DeclarationEmitResolver, } from './transformers/declarations-resolver.js';
 import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
+import { declarationCount, getDeclarations } from './symbol.js';
 const declarationEmitInternalFlags = 8 /* NodeBuilderInternalFlags.AllowUnresolvedNames */;
 const aliasMeaning = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */;
 export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
@@ -105,7 +106,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
         while (exportSymbol !== undefined && !visited.has(exportSymbol)) {
             visited.add(exportSymbol);
             let next = undefined;
-            for (const declaration of exportSymbol.declarations) {
+            for (const declaration of getDeclarations(exportSymbol)) {
                 markDeclarationVisible(c, declaration);
                 if (declaration instanceof ImportEqualsDeclaration &&
                     declaration.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */) {
@@ -144,7 +145,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
             const merged = getMergedSymbol(c, s);
             if (merged === s)
                 continue;
-            for (const d of merged.declarations)
+            for (const d of getDeclarations(merged))
                 if (getSourceFileOfNode(d) === importTarget)
                     return true;
         }
@@ -430,8 +431,8 @@ export function getTypeReferenceSerializationKind(c, typeName, location) {
     let isTypeOnly = false;
     if (typeName.kind === 167 /* SyntaxKind.QualifiedName */) {
         const root = resolveEntityName(c, getFirstIdentifier(typeName), 111551 /* SymbolFlags.Value */, true, true, location);
-        if (root !== undefined && root.declarations.length > 0)
-            isTypeOnly = root.declarations.every(isTypeOnlyImportOrExportDeclaration);
+        if (root !== undefined && declarationCount(root) > 0)
+            isTypeOnly = getDeclarations(root).every(isTypeOnlyImportOrExportDeclaration);
     }
     const valueSymbol = resolveEntityName(c, typeName, 111551 /* SymbolFlags.Value */, true, true, location);
     let resolvedValue = valueSymbol;

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

@@ -3,7 +3,7 @@
 // `checkGrammarSourceFile` walks a file once after it is type checked and runs the grammar checks
 // of each node in the order tsgo's checker runs them. Checks that need types read the checker's
 // caches. Errors reported with `grammarError*` are dropped when the file has parse errors.
-import { ElementAccessExpression, Identifier, NodeVisitor, StringLiteral, getAsteriskToken, getBody, getElements, getExpression, getHeritageClauses, getInitializer, getLabel, getIsTypeOnly, getLocals, getMembers, getModifiers, getName, getNodeId, getParameters, getPostfixToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, isDeclarationNode, } from './ast.js';
+import { ElementAccessExpression, Identifier, NodeVisitor, StringLiteral, getAsteriskToken, getBody, getElements, getExpression, getHeritageClauses, getInitializer, getLabel, getIsTypeOnly, getLocals, getMembers, getModifiers, getName, getNodeId, getParameters, getPostfixToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, isDeclarationNode, callQuestionDotToken, callTypeArguments, } from './ast.js';
 import { canHaveDecorators, canHaveIllegalDecorators, getExternalModuleName, getTextOfNodeFromSourceText, isAmbientModule, isFunctionLike, isFunctionLikeDeclarationKind, isModifierKind, isStringLiteralLike, modifierToFlag, nodeIsPresent, isInJSFile, } from './ast-utilities.js';
 import { getCombinedModifierFlags, getCombinedNodeFlags, getContainingClass, getRangeOfTokenAtPosition, getSourceFileOfNode, hasSyntacticModifier, isAutoAccessorPropertyDeclaration, isClassLike, isDynamicName, isEntityNameExpression, isExternalModule, isInTopLevelContext, isModuleAugmentationExternal, isPrivateIdentifierClassElementDeclaration, isStatic, skipParentheses, } from './binder-utilities.js';
 import { findUseStrictPrologue } from './binder.js';
@@ -20,9 +20,10 @@ import { Diagnostic, messageCategory } from './diagnostics.js';
 import { ModuleKind, ScriptTarget, getEmitModuleKind } from './options.js';
 import { fileExtensionIsOneOf, isExternalModuleNameRelative } from './path.js';
 import { SourceFileMetadata, getEmitModuleFormatOfFile, getImpliedNodeFormatForEmit } from './program-utilities.js';
-import { Scanner, ScannerErrorReporter, computeLineOfPosition, skipTrivia, tokenToString } from './scanner.js';
+import { Scanner, ScannerErrorReporter, skipTrivia, tokenToString } from './scanner.js';
 import { typeToString } from './type-printer.js';
 import { findMismatchedAugmentsTag } from './checker-jsdoc.js';
+import { getDeclarations } from './symbol.js';
 /** Runs the grammar checks of every node of `file`. */
 export function checkGrammarSourceFile(c, file) {
     const g = new GrammarChecker(c, file);
@@ -821,7 +822,7 @@ function getFirstAccessorOfPair(c, node) {
     if (symbol === undefined)
         return node;
     const otherKind = node.kind === 178 /* SyntaxKind.GetAccessor */ ? 179 /* SyntaxKind.SetAccessor */ : 178 /* SyntaxKind.GetAccessor */;
-    for (const declaration of symbol.declarations)
+    for (const declaration of getDeclarations(symbol))
         if (declaration.kind === otherKind && declaration.pos < node.pos)
             return declaration;
     return node;
@@ -857,8 +858,8 @@ function checkGrammarDecorator(g, decorator) {
             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;
@@ -969,10 +970,23 @@ function checkGrammarArrowFunction(g, node) {
     const arrowToken = arrow.equalsGreaterThanToken;
     if (arrowToken === undefined)
         return false;
-    const lineStarts = g.file.lineStarts();
-    return (computeLineOfPosition(lineStarts, arrowToken.pos) !== computeLineOfPosition(lineStarts, arrowToken.end) &&
+    return (hasLineBreak(g.file.text, arrowToken.pos, arrowToken.end) &&
         grammarErrorOnNode(g, arrowToken, 156 /* Diagnostics.Line_terminator_not_permitted_before_arrow */));
 }
+/**
+ * Whether a line starts in `(pos, end]`, so that `pos` and `end` are on different lines: after an
+ * LF, LS or PS, or a CR that no LF follows (`computeLineStarts`), without the file's line starts.
+ */
+function hasLineBreak(text, pos, end) {
+    for (let i = pos; i < end; i++) {
+        const c = text.charCodeAt(i);
+        if (c === 0x0a || c === 0x2028 || c === 0x2029)
+            return true;
+        if (c === 0x0d && text.charCodeAt(i + 1) !== 0x0a)
+            return true;
+    }
+    return false;
+}
 function checkGrammarForGenerator(g, node) {
     const asteriskToken = getAsteriskToken(node);
     if (asteriskToken === undefined)
@@ -2366,7 +2380,7 @@ function checkGrammarCallExpression(g, node) {
     if (isImportCall)
         checkGrammarImportCallExpression(g, node);
     else
-        checkGrammarTypeArguments(g, node.typeArguments);
+        checkGrammarTypeArguments(g, callTypeArguments(node));
 }
 function checkGrammarImportCallExpression(g, node) {
     const moduleKind = g.moduleKind;
@@ -2380,7 +2394,7 @@ function checkGrammarImportCallExpression(g, node) {
     }
     else if (moduleKind === ModuleKind.ES2015)
         return grammarErrorOnNode(g, node, 259 /* 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, 262 /* Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments */);
     const args = node.arguments;
     const argumentNodes = args.nodes;

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

@@ -1,7 +1,7 @@
 import { type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import { type Checker } from './checker.js';
 import { type Type } from './checker-types.js';
+import { type Symbol } from './symbol.js';
 /** Checks a class's merged declarations, members, base class, implemented types and index signatures. */
 export declare function checkClassHeritage(c: Checker, node: Node): void;
 /**

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

@@ -24,6 +24,7 @@ import { checkTypeAssignableTo, checkTypeRelatedTo, compareProperties, isTypeAss
 import { symbolToString, typeToString } from './type-printer.js';
 import { checkFunctionOrConstructorSymbol } from './checker-overloads.js';
 import { isPropertyInitializedInConstructor } from './checker-classes.js';
+import { declarationCount, getDeclarations, } from './symbol.js';
 // ---- Classes
 /** Checks a class's merged declarations, members, base class, implemented types and index signatures. */
 export function checkClassHeritage(c, node) {
@@ -349,7 +350,7 @@ function isImplementedByOtherBaseType(c, t, baseType, base) {
 /** With `useDefineForClassFields`, a redeclared property without an initializer resets the base value. */
 function checkPropertyOverwritesBase(c, t, baseType, base, derived, baseDeclarationFlags, derivedDeclarationFlags) {
     let uninitialized;
-    for (const d of derived.declarations) {
+    for (const d of getDeclarations(derived)) {
         if (d.kind === 173 /* SyntaxKind.PropertyDeclaration */ && getInitializer(d) === undefined) {
             uninitialized = d;
             break;
@@ -360,7 +361,7 @@ function checkPropertyOverwritesBase(c, t, baseType, base, derived, baseDeclarat
         (baseDeclarationFlags & 64 /* ModifierFlags.Abstract */) !== 0 ||
         (derivedDeclarationFlags & 64 /* ModifierFlags.Abstract */) !== 0)
         return;
-    for (const d of derived.declarations)
+    for (const d of getDeclarations(derived))
         if ((d.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
             return;
     const constructor = findConstructorDeclaration(getClassLikeDeclarationOfSymbol(t.symbol));
@@ -404,12 +405,12 @@ function reportMissingAbstractMembers(c, node, missing) {
 function arePropertiesAbstractOrInterface(base, baseDeclarationFlags) {
     // Synthetic (intersection) properties need any declaration to qualify; others need all.
     if ((base.checkFlags & 6 /* CheckFlags.Synthetic */) !== 0) {
-        for (const d of base.declarations)
+        for (const d of getDeclarations(base))
             if (isPropertyAbstractOrInterface(d, baseDeclarationFlags))
                 return true;
         return false;
     }
-    for (const d of base.declarations)
+    for (const d of getDeclarations(base))
         if (!isPropertyAbstractOrInterface(d, baseDeclarationFlags))
             return false;
     return true;
@@ -485,13 +486,13 @@ function checkMemberForOverrideModifier(c, node, staticType, baseStaticType, bas
         return;
     }
     if (baseProp === undefined ||
-        baseProp.declarations.length === 0 ||
+        declarationCount(baseProp) === 0 ||
         memberHasOverrideModifier ||
         c.compilerOptions.noImplicitOverride !== true ||
         (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
         return;
     let baseHasAbstract = false;
-    for (const d of baseProp.declarations) {
+    for (const d of getDeclarations(baseProp)) {
         if (hasSyntacticModifier(d, 64 /* ModifierFlags.Abstract */)) {
             baseHasAbstract = true;
             break;
@@ -590,14 +591,14 @@ function checkInheritedPropertiesAreIdentical(c, t, typeNode) {
 // ---- Type parameters of merged declarations
 /** Reports class and interface declarations of one symbol whose type parameters differ. */
 export function checkTypeParameterListsIdentical(c, symbol) {
-    if (symbol.declarations.length === 1)
+    if (declarationCount(symbol) === 1)
         return;
     const links = c.symbolLinks(symbol);
     if (links.typeParametersChecked)
         return;
     links.typeParametersChecked = true;
     const declarations = [];
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (d.kind === 264 /* SyntaxKind.ClassDeclaration */ || d.kind === 265 /* SyntaxKind.InterfaceDeclaration */)
             declarations.push(d);
     if (declarations.length <= 1)
@@ -618,7 +619,7 @@ export function checkTypeParameterListsIdentical(c, symbol) {
 }
 /** Reports the declarations of an `infer` type parameter declared more than once with different constraints. */
 export function checkInferTypeParameterDeclarations(c, symbol) {
-    if (symbol.declarations.length <= 1)
+    if (declarationCount(symbol) <= 1)
         return;
     const links = c.symbolLinks(symbol);
     if (links.typeParametersChecked)
@@ -626,7 +627,7 @@ export function checkInferTypeParameterDeclarations(c, symbol) {
     links.typeParametersChecked = true;
     const declarations = [];
     const typeParameterLists = [];
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         if (d.kind === 169 /* SyntaxKind.TypeParameter */) {
             declarations.push(d);
             typeParameterLists.push([d]);
@@ -711,7 +712,7 @@ export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNam
     }
 }
 function checkPropertyOrAccessor(c, node, names, symbol, kind, isStaticMember) {
-    if (symbol.declarations.length <= 1)
+    if (declarationCount(symbol) <= 1)
         return;
     const state = names.get(symbol.name) ?? 0 /* MemberKind.None */;
     if (state === 0 /* MemberKind.None */)
@@ -865,12 +866,12 @@ function checkTypeForDuplicateIndexSignatures(c, node) {
     if (symbol === undefined)
         return;
     const indexSymbol = getIndexSymbol(c, symbol);
-    if (indexSymbol === undefined || indexSymbol.declarations.length <= 1)
+    if (indexSymbol === undefined || declarationCount(indexSymbol) <= 1)
         return;
     // Late-bound index signatures may duplicate each other and explicit ones.
     const keyTypes = [];
     const declarationsByKey = [];
-    for (const declaration of indexSymbol.declarations) {
+    for (const declaration of getDeclarations(indexSymbol)) {
         if (declaration.kind !== 182 /* SyntaxKind.IndexSignature */)
             continue;
         const parameters = getParameters(declaration).nodes;

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

@@ -1,8 +1,8 @@
 import { type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import type { Checker } from './checker.js';
 import { type ConditionalRoot, type IndexType, type MappedType, type ReverseMappedType, type Signature, type TemplateLiteralType, type Type, TypeMapper } from './checker-types.js';
 import { type TypeComparer } from './relations.js';
+import { type Symbol } from './symbol.js';
 export declare const enum InferenceFlags {
     None = 0,
     /** Infer `silentNeverType` for no inferences (otherwise `unknown`). */
@@ -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

@@ -2,7 +2,6 @@
 // types of type parameters.
 import { sideOf, signatureSideOf } from './side-state.js';
 import { hasSyntacticModifier } from './binder-utilities.js';
-import { getSymbolId } from './symbol.js';
 import { ArrayToSingleTypeMapper, MergedTypeMapper, TupleElementInfo, TypeMapper, newTypeMapper, SimpleTypeMapper, emptyTypes, } from './checker-types.js';
 import { createAnonymousType, createArrayType, createArrayTypeEx, createTupleType, createTupleTypeEx, filterType, getBaseTypeOfLiteralType, getBigIntLiteralType, getElementTypes, getEndElementCount, getIntersectionType, getNumberLiteralType, getRegularTypeOfLiteralType, getStringLiteralType, getTemplateLiteralType, getTypeArguments, getTypeReferenceArity, getUnionType, getUnionTypeEx, getWidenedLiteralType, isArrayOrTupleType, isErrorType, isArrayType, isGenericTupleType, isLiteralType, isMutableArrayOrTuple, isReadonlyArrayType, isTupleType, mapType, newIndexInfo, newObjectType, setStructuredTypeMembers, someType, tupleTargetOf, typesOf, } from './checker-type-factory.js';
 import { getDeclaredTypeOfClassOrInterface, getDeclaredTypeOfSymbol, fillMissingTypeArguments, getConstraintOfTypeParameter, getDefaultFromTypeParameter, getMinTypeArgumentCount, getDeclaredTypeOfTypeParameter, } from './checker-declared-types.js';
@@ -17,6 +16,7 @@ import { getTypeFromTypeNode } from './checker-type-nodes.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
 import { parsePseudoBigInt } from './pseudo-bigint.js';
 import { getContextualTypeForInference } from './checker-contextual.js';
+import { copyDeclarations, declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 // Shared empty candidate lists: an InferenceInfo gets its own on its first candidate, as tsgo's nil
 // slices do. Never changed.
 const noCandidates = [];
@@ -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)
@@ -179,7 +200,7 @@ function hasTypeParameterDefault(tp) {
     const symbol = tp.symbol;
     if (symbol === undefined)
         return false;
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (d.kind === 169 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
             return true;
     return false;
@@ -991,9 +1012,9 @@ function isTopLevelClassStaticSide(t) {
         (symbol.flags &
             (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 2048 /* SymbolFlags.TypeLiteral */ | 4096 /* SymbolFlags.ObjectLiteral */)) !==
             0 ||
-        symbol.declarations.length === 0)
+        declarationCount(symbol) === 0)
         return false;
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         if (d.kind !== 264 /* SyntaxKind.ClassDeclaration */ &&
             d.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ &&
             d.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
@@ -1031,7 +1052,7 @@ function createEmptyObjectTypeFromStringLiteral(c, t) {
         const literalProp = c.newSymbol(4 /* SymbolFlags.Property */, name);
         c.symbolTypes.set(getSymbolId(literalProp), c.anyType);
         if (u.symbol !== undefined) {
-            literalProp.declarations = u.symbol.declarations;
+            copyDeclarations(literalProp, u.symbol);
             literalProp.valueDeclaration = u.symbol.valueDeclaration;
         }
         members.set(name, literalProp);
@@ -1101,7 +1122,7 @@ function typesDefinitelyUnrelated(c, source, target) {
 function hasUnmatchedProperty(c, source, target, matchDiscriminantProperties) {
     const t = getReducedApparentType(c, target);
     if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) === 0 ||
-        sideOf(c, t).resolvedProperties !== undefined)
+        sideOf(c, t).membersOf?.resolvedProperties !== undefined)
         return getUnmatchedProperty(c, source, target, false, matchDiscriminantProperties) !== undefined;
     const containingType = t;
     const isUnion = (t.flags & 134217728 /* TypeFlags.Union */) !== 0;
@@ -1146,7 +1167,7 @@ export function isConstTypeVariable(c, t, depth) {
     if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
         if (t.symbol === undefined)
             return false;
-        for (const d of t.symbol.declarations)
+        for (const d of getDeclarations(t.symbol))
             if (hasSyntacticModifier(d, 4096 /* ModifierFlags.Const */))
                 return true;
         return false;
@@ -1616,7 +1637,7 @@ export function resolveReverseMappedTypeMembers(c, t) {
         }
         const checkFlags = 8192 /* CheckFlags.ReverseMapped */ | (readonlyMask && isReadonlySymbol(c, prop) ? 8 /* CheckFlags.Readonly */ : 0);
         const inferredProp = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | (prop.flags & optionalMask), prop.name, checkFlags);
-        inferredProp.declarations = prop.declarations;
+        copyDeclarations(inferredProp, prop);
         const links = c.symbolLinks(inferredProp);
         const id = inferredProp.id;
         c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(prop)));
@@ -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);
@@ -2014,7 +2037,7 @@ export function getInferredTypeParameterConstraint(c, t, omitTypeReferences = fa
     const inferences = [];
     const symbol = t.symbol;
     if (symbol !== undefined)
-        for (const declaration of symbol.declarations) {
+        for (const declaration of getDeclarations(symbol)) {
             if (declaration.parent === undefined || declaration.parent.kind !== 196 /* SyntaxKind.InferType */)
                 continue;
             let child = declaration.parent;

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

@@ -1,7 +1,7 @@
 import { BinaryExpression, type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import type { Checker } from './checker.js';
 import { type Type } from './checker-types.js';
+import { type Symbol } from './symbol.js';
 /** The type of the CommonJS `module` symbol or its `exports` property. */
 export declare function getTypeOfModuleExportsSymbol(c: Checker, symbol: Symbol): Type;
 /** The type of a symbol declared by JavaScript assignments or `Object.defineProperty` calls. */