tsc-ts 0.0.5 → 0.0.7

package/src/compiler/checker-elaboration.ts

@@ -16,7 +16,6 @@ import {
 import { getSourceFileOfNode } from './binder-utilities.js';
 import { type Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.js';
 import { SyntaxKind } from './syntax-kind.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import { AccessFlags, SignatureKind, type Type, TypeFlags } from './checker-types.js';
 import { getNumberLiteralType, getUnionType, isTupleType, typesOf } from './checker-type-factory.js';
@@ -49,6 +48,7 @@ import { FunctionFlags, getFunctionFlags } from './checker-utilities.js';
 import { typeToString } from './type-printer.js';
 import { CheckMode } from './checker-types.js';
 import { elaborateJsxComponents } from './checker-jsx.js';
+import { declarationCount, type Symbol, SymbolFlags } from './symbol.js';
 
 /** Checks that `source` relates to `target`, elaborating into `expr` when possible. */
 export function checkTypeRelatedToAndOptionallyElaborate(
@@ -381,13 +381,13 @@ export function elaborateElement(
   }
   if (
     !issuedElaboration &&
-    ((targetProp !== undefined && targetProp.declarations.length !== 0) ||
-      (target.symbol !== undefined && target.symbol.declarations.length !== 0))
+    ((targetProp !== undefined && declarationCount(targetProp) !== 0) ||
+      (target.symbol !== undefined && declarationCount(target.symbol) !== 0))
   ) {
     const targetNode =
-      targetProp !== undefined && targetProp.declarations.length !== 0
-        ? targetProp.declarations[0]!
-        : target.symbol!.declarations[0]!;
+      targetProp !== undefined && declarationCount(targetProp) !== 0
+        ? targetProp.declaration!
+        : target.symbol!.declaration!;
     if (propertyName === '' || (nameType.flags & TypeFlags.UniqueESSymbol) !== 0)
       propertyName = typeToString(c, nameType);
     if (!c.host.isSourceFileDefaultLibrary(getSourceFileOfNode(targetNode)))
@@ -456,10 +456,10 @@ function elaborateArrowFunction(
   checkTypeRelatedTo(c, sourceReturn, targetReturn, relation, returnExpression, undefined, diagnostics);
   if (diagnostics.length === 0) return false;
   const diagnostic = diagnostics[0]!;
-  if (target.symbol !== undefined && target.symbol.declarations.length !== 0)
+  if (target.symbol !== undefined && declarationCount(target.symbol) !== 0)
     diagnostic.addRelatedInfo(
       createDiagnosticForNode(
-        target.symbol.declarations[0]!,
+        target.symbol.declaration!,
         Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature,
         [],
       ),

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-emit-resolver.ts

@@ -95,7 +95,6 @@ import { tryReuseExistingNode } from './node-builder-reuse.js';
 import type { CompilerOptions, ModuleKind } from './options.js';
 import type { EmitContext } from './printer/emit-context.js';
 import { isTypeIdenticalTo } from './relations.js';
-import { CheckFlags, type Symbol, SymbolFlags } from './symbol.js';
 import {
   beginDeclarationEmitVisibility,
   isDeclarationVisible,
@@ -116,6 +115,7 @@ import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
 import type { Evaluation, ReferenceResolver } from './transformers/reference-resolver.js';
 import { TypeReferenceSerializationKind } from './transformers/type-serialization.js';
 import { TokenFlags } from './types.js';
+import { CheckFlags, declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 const declarationEmitInternalFlags = NodeBuilderInternalFlags.AllowUnresolvedNames;
 const aliasMeaning = SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias;
@@ -218,7 +218,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     while (exportSymbol !== undefined && !visited.has(exportSymbol)) {
       visited.add(exportSymbol);
       let next: Symbol | undefined = undefined;
-      for (const declaration of exportSymbol.declarations) {
+      for (const declaration of getDeclarations(exportSymbol)) {
         markDeclarationVisible(c, declaration);
         if (
           declaration instanceof ImportEqualsDeclaration &&
@@ -265,7 +265,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     for (const s of getExportsOfModule(c, file.symbol).values()) {
       const merged = getMergedSymbol(c, s);
       if (merged === s) continue;
-      for (const d of merged.declarations) if (getSourceFileOfNode(d) === importTarget) return true;
+      for (const d of getDeclarations(merged)) if (getSourceFileOfNode(d) === importTarget) return true;
     }
     return false;
   }
@@ -621,8 +621,8 @@ export function getTypeReferenceSerializationKind(
   let isTypeOnly = false;
   if (typeName.kind === SyntaxKind.QualifiedName) {
     const root = resolveEntityName(c, getFirstIdentifier(typeName), 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, SymbolFlags.Value, true, true, location);
   let resolvedValue = valueSymbol;

package/src/compiler/checker-grammar.ts

@@ -80,6 +80,8 @@ import {
   getTypeArguments,
   getTypeParameters,
   isDeclarationNode,
+  callQuestionDotToken,
+  callTypeArguments,
 } from './ast.js';
 import {
   canHaveDecorators,
@@ -130,12 +132,12 @@ import { ModuleKind, ScriptTarget, getEmitModuleKind } from './options.js';
 import { fileExtensionIsOneOf, isExternalModuleNameRelative } from './path.js';
 import { SourceFileMetadata, getEmitModuleFormatOfFile, getImpliedNodeFormatForEmit } from './program-utilities.js';
 import { CharacterCodes } from './character-codes.js';
-import { Scanner, ScannerErrorReporter, computeLineOfPosition, skipTrivia, tokenToString } from './scanner.js';
-import { SymbolFlags } from './symbol.js';
+import { Scanner, ScannerErrorReporter, skipTrivia, tokenToString } from './scanner.js';
 import { typeToString } from './type-printer.js';
 import type { ScriptTarget as LanguageTarget } from './types.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { findMismatchedAugmentsTag } from './checker-jsdoc.js';
+import { getDeclarations, SymbolFlags } from './symbol.js';
 
 /** Runs the grammar checks of every node of `file`. */
 export function checkGrammarSourceFile(c: Checker, file: SourceFile): void {
@@ -1266,7 +1268,7 @@ function getFirstAccessorOfPair(c: Checker, node: Node): Node {
   const symbol = getSymbolOfDeclaration(c, node);
   if (symbol === undefined) return node;
   const otherKind = node.kind === SyntaxKind.GetAccessor ? SyntaxKind.SetAccessor : 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;
 }
@@ -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;
@@ -1437,13 +1439,25 @@ function checkGrammarArrowFunction(g: GrammarChecker, node: Node): boolean {
   }
   const arrowToken = arrow.equalsGreaterThanToken;
   if (arrowToken === undefined) return false;
-  const lineStarts = g.file.lineStarts();
   return (
-    computeLineOfPosition(lineStarts, arrowToken.pos) !== computeLineOfPosition(lineStarts, arrowToken.end) &&
+    hasLineBreak(g.file.text, arrowToken.pos, arrowToken.end) &&
     grammarErrorOnNode(g, arrowToken, 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: string, pos: number, end: number): boolean {
+  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: GrammarChecker, node: Node): boolean {
   const asteriskToken = getAsteriskToken(node);
   if (asteriskToken === undefined) return false;
@@ -3293,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 {
@@ -3319,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-heritage.ts

@@ -31,7 +31,6 @@ import {
 } from './binder-utilities.js';
 import { type Diagnostic, type DiagnosticMessage, Diagnostics, chainDiagnostic } from './diagnostics.js';
 import { getUseDefineForClassFields } from './options.js';
-import { CheckFlags, InternalSymbolName, type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import {
@@ -115,6 +114,14 @@ import { Ternary } from './checker-types.js';
 import { symbolToString, typeToString } from './type-printer.js';
 import { checkFunctionOrConstructorSymbol } from './checker-overloads.js';
 import { isPropertyInitializedInConstructor } from './checker-classes.js';
+import {
+  CheckFlags,
+  declarationCount,
+  getDeclarations,
+  InternalSymbolName,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 // ---- Classes
 
@@ -519,7 +526,7 @@ function checkPropertyOverwritesBase(
   derivedDeclarationFlags: ModifierFlags,
 ): void {
   let uninitialized: Node | undefined;
-  for (const d of derived.declarations) {
+  for (const d of getDeclarations(derived)) {
     if (d.kind === SyntaxKind.PropertyDeclaration && getInitializer(d) === undefined) {
       uninitialized = d;
       break;
@@ -532,7 +539,7 @@ function checkPropertyOverwritesBase(
     (derivedDeclarationFlags & ModifierFlags.Abstract) !== 0
   )
     return;
-  for (const d of derived.declarations) if ((d.flags & NodeFlags.Ambient) !== 0) return;
+  for (const d of getDeclarations(derived)) if ((d.flags & NodeFlags.Ambient) !== 0) return;
   const constructor = findConstructorDeclaration(getClassLikeDeclarationOfSymbol(t.symbol!)!);
   const propName = getName(uninitialized)!;
   const postfix = getPostfixToken(uninitialized);
@@ -618,10 +625,10 @@ function reportMissingAbstractMembers(c: Checker, node: Node | undefined, missin
 function arePropertiesAbstractOrInterface(base: Symbol, baseDeclarationFlags: ModifierFlags): boolean {
   // Synthetic (intersection) properties need any declaration to qualify; others need all.
   if ((base.checkFlags & CheckFlags.Synthetic) !== 0) {
-    for (const d of base.declarations) if (isPropertyAbstractOrInterface(d, baseDeclarationFlags)) return true;
+    for (const d of getDeclarations(base)) if (isPropertyAbstractOrInterface(d, baseDeclarationFlags)) return true;
     return false;
   }
-  for (const d of base.declarations) if (!isPropertyAbstractOrInterface(d, baseDeclarationFlags)) return false;
+  for (const d of getDeclarations(base)) if (!isPropertyAbstractOrInterface(d, baseDeclarationFlags)) return false;
   return true;
 }
 
@@ -733,14 +740,14 @@ function checkMemberForOverrideModifier(
   }
   if (
     baseProp === undefined ||
-    baseProp.declarations.length === 0 ||
+    declarationCount(baseProp) === 0 ||
     memberHasOverrideModifier ||
     c.compilerOptions.noImplicitOverride !== true ||
     (node.flags & NodeFlags.Ambient) !== 0
   )
     return;
   let baseHasAbstract = false;
-  for (const d of baseProp.declarations) {
+  for (const d of getDeclarations(baseProp)) {
     if (hasSyntacticModifier(d, ModifierFlags.Abstract)) {
       baseHasAbstract = true;
       break;
@@ -869,12 +876,12 @@ function checkInheritedPropertiesAreIdentical(c: Checker, t: InterfaceType, type
 
 /** Reports class and interface declarations of one symbol whose type parameters differ. */
 export function checkTypeParameterListsIdentical(c: Checker, symbol: Symbol): void {
-  if (symbol.declarations.length === 1) return;
+  if (declarationCount(symbol) === 1) return;
   const links = c.symbolLinks(symbol);
   if (links.typeParametersChecked) return;
   links.typeParametersChecked = true;
   const declarations: Node[] = [];
-  for (const d of symbol.declarations)
+  for (const d of getDeclarations(symbol))
     if (d.kind === SyntaxKind.ClassDeclaration || d.kind === SyntaxKind.InterfaceDeclaration) declarations.push(d);
   if (declarations.length <= 1) return;
   const t = getDeclaredTypeOfSymbol(c, symbol) as InterfaceType;
@@ -892,13 +899,13 @@ export function checkTypeParameterListsIdentical(c: Checker, symbol: Symbol): vo
 
 /** Reports the declarations of an `infer` type parameter declared more than once with different constraints. */
 export function checkInferTypeParameterDeclarations(c: Checker, symbol: Symbol): void {
-  if (symbol.declarations.length <= 1) return;
+  if (declarationCount(symbol) <= 1) return;
   const links = c.symbolLinks(symbol);
   if (links.typeParametersChecked) return;
   links.typeParametersChecked = true;
   const declarations: Node[] = [];
   const typeParameterLists: Node[][] = [];
-  for (const d of symbol.declarations) {
+  for (const d of getDeclarations(symbol)) {
     if (d.kind === SyntaxKind.TypeParameter) {
       declarations.push(d);
       typeParameterLists.push([d]);
@@ -1020,7 +1027,7 @@ function checkPropertyOrAccessor(
   kind: MemberKind,
   isStaticMember: boolean,
 ): void {
-  if (symbol.declarations.length <= 1) return;
+  if (declarationCount(symbol) <= 1) return;
   const state = names.get(symbol.name) ?? MemberKind.None;
   if (state === MemberKind.None) names.set(symbol.name, kind);
   // A second property, or a property combined with an accessor.
@@ -1203,11 +1210,11 @@ function checkTypeForDuplicateIndexSignatures(c: Checker, node: Node): void {
   const symbol = getSymbolOfDeclaration(c, node);
   if (symbol === undefined) return;
   const indexSymbol = getIndexSymbol(c, symbol);
-  if (indexSymbol === undefined || indexSymbol.declarations.length <= 1) return;
+  if (indexSymbol === undefined || declarationCount(indexSymbol) <= 1) return;
   // Late-bound index signatures may duplicate each other and explicit ones.
   const keyTypes: Type[] = [];
   const declarationsByKey: Node[][] = [];
-  for (const declaration of indexSymbol.declarations) {
+  for (const declaration of getDeclarations(indexSymbol)) {
     if (declaration.kind !== SyntaxKind.IndexSignature) continue;
     const parameters = getParameters(declaration)!.nodes;
     if (parameters.length !== 1) continue;

package/src/compiler/checker-inference.ts

@@ -13,7 +13,6 @@ import {
   type ConditionalTypeNode,
 } from './ast.js';
 import { hasSyntacticModifier } from './binder-utilities.js';
-import { CheckFlags, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import type { Checker } from './checker.js';
 import {
@@ -194,6 +193,15 @@ 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 {
+  CheckFlags,
+  copyDeclarations,
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 export const enum InferenceFlags {
   None = 0,
@@ -285,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,
@@ -307,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[],
@@ -394,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 {
@@ -427,7 +458,7 @@ export function someInferenceHasCandidatesOrDefault(inferences: InferenceInfo[])
 function hasTypeParameterDefault(tp: Type): boolean {
   const symbol = tp.symbol;
   if (symbol === undefined) return false;
-  for (const d of symbol.declarations)
+  for (const d of getDeclarations(symbol))
     if (d.kind === SyntaxKind.TypeParameter && (d as TypeParameterDeclaration).defaultType !== undefined) return true;
   return false;
 }
@@ -1324,10 +1355,10 @@ function isTopLevelClassStaticSide(t: Type): boolean {
     (symbol.flags &
       (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.TypeLiteral | 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 !== SyntaxKind.ClassDeclaration &&
       d.kind !== SyntaxKind.InterfaceDeclaration &&
@@ -1370,7 +1401,7 @@ function createEmptyObjectTypeFromStringLiteral(c: Checker, t: Type): Type {
     const literalProp = c.newSymbol(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);
@@ -1452,7 +1483,7 @@ function hasUnmatchedProperty(c: Checker, source: Type, target: Type, matchDiscr
   const t = getReducedApparentType(c, target);
   if (
     (t.flags & TypeFlags.UnionOrIntersection) === 0 ||
-    sideOf(c, t as UnionOrIntersectionType).resolvedProperties !== undefined
+    sideOf(c, t as UnionOrIntersectionType).membersOf?.resolvedProperties !== undefined
   )
     return getUnmatchedProperty(c, source, target, false, matchDiscriminantProperties) !== undefined;
   const containingType = t as UnionOrIntersectionType;
@@ -1495,7 +1526,7 @@ export function isConstTypeVariable(c: Checker, t: Type | undefined, depth: numb
   if (depth >= 5 || t === undefined) return false;
   if ((t.flags & TypeFlags.TypeParameter) !== 0) {
     if (t.symbol === undefined) return false;
-    for (const d of t.symbol.declarations) if (hasSyntacticModifier(d, ModifierFlags.Const)) return true;
+    for (const d of getDeclarations(t.symbol)) if (hasSyntacticModifier(d, ModifierFlags.Const)) return true;
     return false;
   }
   if ((t.flags & TypeFlags.UnionOrIntersection) !== 0) {
@@ -2031,7 +2062,7 @@ export function resolveReverseMappedTypeMembers(c: Checker, t: ReverseMappedType
       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)));
@@ -2118,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)
@@ -2394,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(
@@ -2484,7 +2516,7 @@ export function getInferredTypeParameterConstraint(c: Checker, t: Type, omitType
   const inferences: Type[] = [];
   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 !== SyntaxKind.InferType) continue;
       let child: Node = declaration.parent;
       let parent = child.parent;

package/src/compiler/checker-javascript.ts

@@ -30,7 +30,6 @@ import {
   isStringOrNumericLiteralLike,
   isVariableDeclarationInitializedToRequire,
 } from './binder-utilities.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import type { Checker } from './checker.js';
 import { ObjectFlags, type Type, TypeFlags } from './checker-types.js';
@@ -67,6 +66,7 @@ import {
   getTypeOfPropertyInBaseClass,
   isAutoTypedProperty,
 } from './checker-classes.js';
+import { declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 /** How the `this.x` assignments declaring a property are typed. */
 const enum ThisAssignmentKind {
@@ -99,7 +99,7 @@ export function getWidenedTypeForAssignmentDeclaration(c: Checker, symbol: Symbo
   else if (kind === ThisAssignmentKind.Method) t = getTypeOfPropertyInBaseClass(c, symbol);
   if (t === undefined) {
     const types: Type[] = [];
-    const declarations = symbol.declarations;
+    const declarations = getDeclarations(symbol);
     for (let i = 0; i < declarations.length; i++) {
       const declaration = declarations[i]!;
       const declaredType = declaration instanceof BinaryExpression ? (declaration as BinaryExpression).type : undefined;
@@ -234,7 +234,7 @@ function getThisAssignmentKind(c: Checker, symbol: Symbol): ThisAssignmentKind {
   if (links.thisAssignmentKind !== 0) return (links.thisAssignmentKind - 1) as ThisAssignmentKind;
   let allThis = true;
   let typeAnnotation: Node | undefined;
-  for (const declaration of symbol.declarations) {
+  for (const declaration of getDeclarations(symbol)) {
     if (!(declaration instanceof BinaryExpression)) {
       allThis = false;
       break;
@@ -276,7 +276,7 @@ export function isConstructorDeclaredThisProperty(c: Checker, symbol: Symbol): b
 }
 
 function getDeclaringConstructor(symbol: Symbol): Node | undefined {
-  for (const declaration of symbol.declarations) {
+  for (const declaration of getDeclarations(symbol)) {
     const container = getThisContainer(declaration, false, false);
     if (container.kind === SyntaxKind.Constructor) return container;
   }
@@ -498,5 +498,5 @@ export function isUndefinedAssignmentToCommonJSExport(c: Checker, left: Node, ri
   if (assignment.symbol === undefined) return false;
   if (getAssignmentDeclarationKind(assignment) !== JSDeclarationKind.ExportsProperty) return false;
   const symbol = c.resolvedSymbols.get(left.id);
-  return symbol !== undefined && symbol.declarations.length > 1 && (rightType.flags & TypeFlags.Undefined) !== 0;
+  return symbol !== undefined && declarationCount(symbol) > 1 && (rightType.flags & TypeFlags.Undefined) !== 0;
 }

package/src/compiler/checker-jsx.ts

@@ -30,7 +30,6 @@ import { Diagnostic, type DiagnosticMessage, Diagnostics, chainDiagnostic } from
 import { JsxEmit } from './options.js';
 import { parseIsolatedEntityName } from './parser.js';
 import { skipTrivia } from './scanner.js';
-import { InternalSymbolName, type Symbol, SymbolFlags, type SymbolTable, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import {
@@ -162,6 +161,15 @@ import { getIndexedAccessType } from './checker-type-operators.js';
 import { filterType, isTupleType } from './checker-type-factory.js';
 import { createTypeFromGenericGlobalType } from './checker-type-factory.js';
 import { isTypeAssignableTo } from './relations.js';
+import {
+  copyDeclarations,
+  declarationCount,
+  getSymbolId,
+  InternalSymbolName,
+  type Symbol,
+  SymbolFlags,
+  type SymbolTable,
+} from './symbol.js';
 
 const enum JsxFlags {
   None = 0,
@@ -549,12 +557,8 @@ function getNameFromJsxElementAttributesContainer(c: Checker, containerName: str
       const props = getPropertiesOfType(c, getDeclaredTypeOfSymbol(c, sym));
       if (props.length === 0) return '';
       if (props.length === 1) return props[0]!.name;
-      if (sym.declarations.length !== 0)
-        c.error(
-          sym.declarations[0]!,
-          Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property,
-          containerName,
-        );
+      if (declarationCount(sym) !== 0)
+        c.error(sym.declaration!, Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, containerName);
     }
   }
   return InternalSymbolName.Missing;
@@ -953,7 +957,7 @@ export function createJsxAttributesTypeFromAttributesProperty(
         const exprType = checkJsxAttribute(c, attributeDecl, checkMode);
         objectFlags |= exprType.objectFlags & ObjectFlags.PropagatingFlags;
         const attributeSymbol = c.newSymbol(SymbolFlags.Property | member.flags, member.name);
-        attributeSymbol.declarations = member.declarations;
+        copyDeclarations(attributeSymbol, member);
         attributeSymbol.parent = member.parent;
         if (member.valueDeclaration !== undefined) attributeSymbol.valueDeclaration = member.valueDeclaration;
         const id = getSymbolId(attributeSymbol);