tsc-ts 0.0.10 → 0.1.0

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

@@ -141,6 +141,12 @@ import {
 } from './symbol.js';
 
 export function getTypeOfSymbol(c: Checker, symbol: Symbol): Type {
+  // TSC_TS_SHARE: checker threads share the value types of variables and properties (shared-results.ts).
+  if (c.threadSharing !== undefined && isSharedValueSymbol(symbol)) {
+    const sharing = c.threadSharing;
+    if (sharing.computing === symbol) sharing.computing = undefined;
+    else return threadTypeOfSymbol(c, symbol);
+  }
   const checkFlags = symbol.checkFlags;
   if ((checkFlags & CheckFlags.DeferredType) !== 0) return getTypeOfSymbolWithDeferredType(c, symbol);
   if ((checkFlags & CheckFlags.Instantiated) !== 0) return getTypeOfInstantiatedSymbol(c, symbol);
@@ -277,7 +283,13 @@ function getTypeOfVariableOrParameterOrPropertyWorker(c: Checker, symbol: Symbol
     case SyntaxKind.PropertySignature:
     case SyntaxKind.VariableDeclaration:
     case SyntaxKind.BindingElement:
-      result = getWidenedTypeForVariableLikeDeclaration(c, declaration, true);
+      // A parameter of a context sensitive function may get another type when its context is known, so
+      // its widening errors are left to that.
+      result = getWidenedTypeForVariableLikeDeclaration(
+        c,
+        declaration,
+        !isParameterOfContextSensitiveSignature(c, symbol),
+      );
       break;
     case SyntaxKind.PropertyAssignment:
     case SyntaxKind.ShorthandPropertyAssignment:
@@ -684,11 +696,21 @@ export function reportImplicitAny(
         return;
       }
       if (c.noImplicitAny && (declaration.flags & NodeFlags.Reparsed) !== 0) {
-        c.error(
-          declaration,
-          Diagnostics.This_overload_implicitly_returns_the_type_0_because_it_lacks_a_return_type_annotation,
-          typeAsString,
-        );
+        // A JSDoc `@overload`.
+        const nameText = declarationNameToString(file, getNameOfDeclaration(declaration));
+        if (nameText !== '')
+          c.error(
+            declaration,
+            Diagnostics.X_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type,
+            nameText,
+            typeAsString,
+          );
+        else
+          c.error(
+            declaration,
+            Diagnostics.This_overload_implicitly_returns_the_type_0_because_it_lacks_a_return_type_annotation,
+            typeAsString,
+          );
         return;
       }
       if (!c.noImplicitAny)
@@ -980,6 +1002,7 @@ import { getParameterTypeOfFullSignature } from './checker-jsdoc.js';
 import { isFunctionLikeDeclarationKind, isInJSFile } from './ast-utilities.js';
 import { isEmptyArrayLiteralType } from './relations.js';
 import { isCheckJsEnabledForFile } from './program-utilities.js';
+import { isSharedValueSymbol, threadTypeOfSymbol } from './shared-results.js';
 
 function getDeclarationModifierFlags(c: Checker, symbol: Symbol): ModifierFlags {
   return getDeclarationModifierFlagsFromSymbol(c, symbol, false);

package/src/compiler/checker-symbols.ts

@@ -5,14 +5,16 @@ import { isTypeAssignableToKindEx } from './checker-type-operators.js';
 import {
   BinaryExpression,
   type ElementAccessExpression,
+  type ExportAssignment,
   type Identifier,
   ModuleDeclaration,
   type Node,
   NodeFlags,
-  type PatternAmbientModule,
+  PatternAmbientModule,
   type QualifiedName,
   type SourceFile,
   Tristate,
+  type TypeReferenceNode,
   getExpression,
   getInitializer,
   getMembers as getMemberNodes,
@@ -61,7 +63,12 @@ import { getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { symbolToString } from './type-printer.js';
 import { getTypeOfSymbol } from './checker-symbol-types.js';
 import { getPropertyOfType } from './checker-members.js';
-import { checkComputedPropertyName, checkExpressionCached, entityNameToString } from './checker-expressions.js';
+import {
+  checkComputedPropertyName,
+  checkExpressionCached,
+  entityNameToString,
+  isConstTypeReference,
+} from './checker-expressions.js';
 import {
   getLateBindableNameOfDeclaration,
   getPropertyNameFromType,
@@ -74,6 +81,7 @@ import {
   markAliasDeclarationOfNameIfTypeOnly,
   getExportsOfModuleWorker,
   getTargetOfAliasDeclaration,
+  getTypeOfModuleImportAttributes,
   getTypeOnlyAliasDeclaration,
   isTypeOnlyImportOrExportDeclaration,
   resolveExternalModuleNameWorker,
@@ -81,6 +89,7 @@ import {
   resolveIndirectionAlias,
 } from './checker-modules.js';
 import { isJSAliasDeclaration } from './checker-javascript.js';
+import { isTypeIdenticalTo } from './relations.js';
 import { getFeatureMap } from './checker-features.js';
 import { NodeBuilderInternalFlags } from './transformers/declarations-resolver.js';
 import {
@@ -95,6 +104,7 @@ import {
   Symbol,
   SymbolFlags,
   type SymbolTable,
+  tryGetAmbientModuleNameFromSymbolName,
 } from './symbol.js';
 
 // ---- Name resolution
@@ -332,6 +342,13 @@ function isES2015OrLaterConstructorName(name: string): boolean {
   );
 }
 
+/**
+ * The name-not-found message of an identifier resolved from its own location, chosen only once the name
+ * isn't found (`onFailedToResolveSymbol`). Choosing it up front, as tsgo does, compares every resolved
+ * identifier's text with the list of names `getCannotFindNameDiagnosticForName` has messages for.
+ */
+export const cannotFindNameAtLocation = -1 as DiagnosticMessage;
+
 function onFailedToResolveSymbol(
   c: Checker,
   location: Node | undefined,
@@ -339,8 +356,11 @@ function onFailedToResolveSymbol(
   meaning: SymbolFlags,
   message: DiagnosticMessage,
 ): void {
+  if (message === cannotFindNameAtLocation) message = getCannotFindNameDiagnosticForName(c, location!);
   let declarationName = name;
   if (location !== undefined) {
+    // The `const` of a `const` assertion is not a name.
+    if (isConstTypeReferenceName(location)) return;
     if (location.parent !== undefined && location.parent.kind === SyntaxKind.JSDocLink) return;
     if (
       checkAndReportErrorForMissingPrefix(c, location, name) ||
@@ -446,8 +466,11 @@ function checkAndReportErrorForExtendingInterface(c: Checker, location: Node): b
 function getEntityNameForExtendingInterface(node: Node): Node | undefined {
   switch (node.kind) {
     case SyntaxKind.Identifier:
+    case SyntaxKind.QualifiedName:
     case SyntaxKind.PropertyAccessExpression:
       return node.parent !== undefined ? getEntityNameForExtendingInterface(node.parent) : undefined;
+    case SyntaxKind.TypeReference:
+      return (node as TypeReferenceNode).typeName;
     case SyntaxKind.ExpressionWithTypeArguments: {
       const expression = getExpression(node)!;
       return isEntityNameExpression(expression, false) ? expression : undefined;
@@ -575,7 +598,7 @@ function checkAndReportErrorForUsingTypeAsNamespace(
   if (symbol === undefined) return false;
   const parent = location.parent;
   if (parent !== undefined && parent.kind === SyntaxKind.QualifiedName) {
-    const propName = (parent as QualifiedName).right.text;
+    const propName = getText((parent as QualifiedName).right);
     if (getPropertyOfType(c, getDeclaredTypeOfSymbol(c, symbol), propName) !== undefined) {
       c.error(
         parent,
@@ -602,6 +625,34 @@ function checkAndReportErrorForExportingPrimitiveType(c: Checker, location: Node
   return false;
 }
 
+/** Whether `node` is the `const` of a `const` assertion (`x as const`, `<const>x`). */
+function isConstTypeReferenceName(node: Node): boolean {
+  const parent = node.parent;
+  return (
+    node.kind === SyntaxKind.Identifier &&
+    parent !== undefined &&
+    isConstTypeReference(parent) &&
+    parent.parent !== undefined &&
+    (parent.parent.kind === SyntaxKind.AsExpression || parent.parent.kind === SyntaxKind.TypeAssertionExpression)
+  );
+}
+
+/** Whether `node` is the expression of an `export =` or `export default`, or the leftmost name of it. */
+function isExportAssignmentExpressionName(node: Node): boolean {
+  let current = node;
+  while (
+    current.parent !== undefined &&
+    (current.parent.kind === SyntaxKind.PropertyAccessExpression || current.parent.kind === SyntaxKind.QualifiedName)
+  )
+    current = current.parent;
+  const parent = current.parent;
+  return (
+    parent !== undefined &&
+    parent.kind === SyntaxKind.ExportAssignment &&
+    (parent as ExportAssignment).expression === current
+  );
+}
+
 function checkAndReportErrorForUsingNamespaceAsTypeOrValue(
   c: Checker,
   location: Node,
@@ -614,7 +665,9 @@ function checkAndReportErrorForUsingNamespaceAsTypeOrValue(
       resolveName(c, location, name, SymbolFlags.NamespaceModule, undefined, false, false),
     );
     if (symbol !== undefined) {
-      c.error(location, Diagnostics.Cannot_use_namespace_0_as_a_value, name);
+      // checkExportAssignment decides whether `export = ns` is an error.
+      if (!isExportAssignmentExpressionName(location))
+        c.error(location, Diagnostics.Cannot_use_namespace_0_as_a_value, name);
       return true;
     }
   } else if ((meaning & (SymbolFlags.Type & ~SymbolFlags.Value)) !== 0) {
@@ -670,6 +723,8 @@ function checkAndReportErrorForUsingTypeAsValue(
     resolveName(c, location, name, SymbolFlags.Type & ~SymbolFlags.Value, undefined, false, false),
   );
   if (symbol !== undefined && (getSymbolFlags(c, symbol) & SymbolFlags.Value) === 0) {
+    // checkExportAssignment decides whether `export = T` of a type is an error.
+    if (isExportAssignmentExpressionName(location)) return true;
     if (isES2015OrLaterConstructorName(name))
       c.error(
         location,
@@ -836,6 +891,7 @@ export class MergedGlobals {
   readonly ambientModuleSymbols: Symbol[];
   readonly patternAmbientModules: PatternAmbientModule[];
   readonly patternAmbientModuleAugmentations: Map<string, Symbol>;
+  readonly patternAmbientModuleAugmentationTargets: Map<string, Symbol>;
   /** Whether the global `undefined` is the checker's own (no declaration of `undefined` merged). */
   readonly ownUndefined: boolean;
   /** Ids of the symbols merged into each shared symbol. */
@@ -854,6 +910,7 @@ export class MergedGlobals {
     this.ambientModuleSymbols = c.ambientModuleSymbols.slice();
     this.patternAmbientModules = c.patternAmbientModules.slice();
     this.patternAmbientModuleAugmentations = new Map(c.patternAmbientModuleAugmentations);
+    this.patternAmbientModuleAugmentationTargets = new Map(c.patternAmbientModuleAugmentationTargets);
     for (const [id, target] of this.mergedSymbols) {
       let ids = this.sources.get(target);
       if (ids === undefined) {
@@ -970,6 +1027,8 @@ export function initializeGlobals(c: Checker): void {
     for (const pattern of merged.patternAmbientModules) c.patternAmbientModules.push(pattern);
     for (const [name, symbol] of merged.patternAmbientModuleAugmentations)
       c.patternAmbientModuleAugmentations.set(name, symbol);
+    for (const [name, symbol] of merged.patternAmbientModuleAugmentationTargets)
+      c.patternAmbientModuleAugmentationTargets.set(name, symbol);
     addMergeDiagnostics(c, merged, 0);
     if (merged.ownUndefined) setGlobal(c, 'undefined', c.undefinedSymbol);
     return;
@@ -1016,6 +1075,7 @@ export function mergeAmbientModulesAndAugmentations(c: Checker): void {
     return;
   }
   for (const symbol of c.ambientModuleSymbols) mergeGlobalSymbol(c, symbol);
+  mergePatternAmbientModules(c);
   for (const file of c.files)
     for (const augmentation of file.moduleAugmentations)
       if (augmentation.parent !== undefined && !isGlobalScopeAugmentation(augmentation.parent))
@@ -1023,7 +1083,7 @@ export function mergeAmbientModulesAndAugmentations(c: Checker): void {
 }
 
 export function isAmbientModuleSymbolName(name: string): boolean {
-  return name.length >= 2 && name.charCodeAt(0) === 0x22 && name.charCodeAt(name.length - 1) === 0x22;
+  return tryGetAmbientModuleNameFromSymbolName(name) !== undefined;
 }
 
 function isTypeDeclaration(node: Node): boolean {
@@ -1053,6 +1113,44 @@ function mergeGlobalSymbol(c: Checker, symbol: Symbol): void {
   );
 }
 
+/** Merges the pattern ambient modules with the same pattern and identical import attributes types. */
+function mergePatternAmbientModules(c: Checker): void {
+  const modules = c.patternAmbientModules;
+  if (modules.length === 0) return;
+  const groupsByPattern = new Map<string, number[]>();
+  const grouped: PatternAmbientModule[] = [];
+  for (const module of modules) {
+    const attributesType = getTypeOfModuleImportAttributes(c, module.symbol);
+    let groups = groupsByPattern.get(module.text);
+    let groupIndex = -1;
+    if (groups !== undefined)
+      for (const index of groups)
+        if (isTypeIdenticalTo(c, attributesType, getTypeOfModuleImportAttributes(c, grouped[index]!.symbol))) {
+          groupIndex = index;
+          break;
+        }
+    if (groupIndex === -1) {
+      if (groups === undefined) {
+        groups = [];
+        groupsByPattern.set(module.text, groups);
+      }
+      groups.push(grouped.length);
+      grouped.push(new PatternAmbientModule(module.text, module.starIndex, module.symbol));
+    } else {
+      const group = grouped[groupIndex]!;
+      grouped[groupIndex] = new PatternAmbientModule(
+        group.text,
+        group.starIndex,
+        mergeSymbol(c, group.symbol, module.symbol, false),
+      );
+    }
+  }
+  for (const module of modules)
+    if (c.globals.has(module.symbol.name)) setGlobal(c, module.symbol.name, getMergedSymbol(c, module.symbol));
+  modules.length = 0;
+  for (const module of grouped) modules.push(module);
+}
+
 function mergeModuleAugmentation(c: Checker, moduleName: Node): void {
   const moduleNode = moduleName.parent as ModuleDeclaration;
   const augmentationSymbol = moduleNode.symbol!;
@@ -1067,14 +1165,25 @@ function mergeModuleAugmentation(c: Checker, moduleName: Node): void {
     (moduleNode.parent!.flags & NodeFlags.Ambient) === 0
       ? Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found
       : undefined;
-  let mainModule = resolveExternalModuleNameWorker(c, moduleName, moduleName, moduleNotFoundError, false, true);
+  // Module augmentations can't have import attributes.
+  let mainModule = resolveExternalModuleNameWorker(
+    c,
+    moduleName,
+    moduleName,
+    moduleNotFoundError,
+    false,
+    true,
+    undefined,
+  );
   if (mainModule === undefined) return;
   mainModule = resolveExternalModuleSymbol(c, mainModule, false)!;
   if ((mainModule.flags & SymbolFlags.Namespace) !== 0) {
     for (const pattern of c.patternAmbientModules)
-      if (pattern.symbol === mainModule) {
+      if (getMergedSymbol(c, pattern.symbol) === mainModule) {
+        // Merging the pattern into the augmentation keeps the pattern's own exports unchanged.
         const merged = mergeSymbol(c, augmentationSymbol, mainModule, true);
         c.patternAmbientModuleAugmentations.set(getText(moduleName), merged);
+        c.patternAmbientModuleAugmentationTargets.set(getText(moduleName), mainModule);
         return;
       }
     // Exports the module gets through `export *` live on the re-exported symbols; merge into those.
@@ -1231,11 +1340,7 @@ function hasMatchingDiagnostic(diagnostics: readonly Diagnostic[], a: Diagnostic
 }
 
 function lookupOrIssueError(c: Checker, location: Node, message: DiagnosticMessage, args: string[]) {
-  const diagnostic = createDiagnosticForNode(location, message, args);
-  const existing = c.diagnostics.lookup(diagnostic);
-  if (existing !== undefined) return existing;
-  c.addDiagnostic(diagnostic);
-  return diagnostic;
+  return c.addDiagnostic(createDiagnosticForNode(location, message, args));
 }
 
 export function getExcludedSymbolFlags(flags: SymbolFlags): SymbolFlags {
@@ -1786,6 +1891,42 @@ export function getNamedMembers(c: Checker, members: SymbolTable | undefined, co
   return contained.length === 0 ? rest : contained.concat(rest);
 }
 
+/**
+ * `getNamedMembers(c, table, container)` for a table that holds `members` in this order under their names, as
+ * positions in `members`; undefined where a member is an alias (`symbolIsValue` then resolves it) or a name repeats.
+ */
+export function getNamedMemberPositions(
+  c: Checker,
+  members: Symbol[],
+  container: Symbol | undefined,
+): number[] | undefined {
+  const isClassOrInterface =
+    container !== undefined && (container.flags & (SymbolFlags.Class | SymbolFlags.Interface)) !== 0;
+  const names = new Set<string>();
+  const contained: number[] = [];
+  const rest: number[] = [];
+  for (let i = 0; i < members.length; i++) {
+    const symbol = members[i]!;
+    if ((symbol.flags & SymbolFlags.Alias) !== 0 || names.has(symbol.name)) return undefined;
+    names.add(symbol.name);
+    if (isReservedMemberName(symbol.name) || !symbolIsValue(c, symbol)) continue;
+    if (isClassOrInterface && isDeclarationContainedBy(symbol, container!)) contained.push(i);
+    else rest.push(i);
+  }
+  sortPositions(c, members, contained);
+  sortPositions(c, members, rest);
+  return contained.length === 0 ? rest : contained.concat(rest);
+}
+
+/** `sortSymbols` for positions in `members`. */
+function sortPositions(c: Checker, members: Symbol[], positions: number[]): void {
+  for (let i = 1; i < positions.length; i++)
+    if (compareSymbols(c, members[positions[i - 1]!]!, members[positions[i]!]!) > 0) {
+      positions.sort((a, b) => compareSymbols(c, members[a]!, members[b]!));
+      return;
+    }
+}
+
 /** Sorts symbols by declaration order; members are usually in that order already. */
 function sortSymbols(c: Checker, symbols: Symbol[]): void {
   for (let i = 1; i < symbols.length; i++)
@@ -1821,7 +1962,9 @@ export function resolveEntityName(
       ? undefined
       : meaning === SymbolFlags.Namespace || (name.flags & NodeFlags.Synthesized) !== 0
         ? Diagnostics.Cannot_find_namespace_0
-        : getCannotFindNameDiagnosticForName(c, getFirstIdentifier(name));
+        : location === undefined
+          ? cannotFindNameAtLocation
+          : getCannotFindNameDiagnosticForName(c, getFirstIdentifier(name));
     const resolveLocation = location ?? name;
     const text = getText(name);
     if (meaning === SymbolFlags.Namespace) {
@@ -1931,7 +2074,7 @@ function resolveQualifiedName(
         qualified.right,
         Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1,
         symbolToString(c, getMergedSymbol(c, exportedType)),
-        qualified.right.text,
+        getText(qualified.right),
       );
       return undefined;
     }
@@ -1947,7 +2090,7 @@ function tryGetQualifiedNameAsValue(c: Checker, node: Node): Symbol | undefined
   if (symbol === undefined) return undefined;
   let current: Node = id;
   while (current.parent!.kind === SyntaxKind.QualifiedName) {
-    symbol = getPropertyOfType(c, getTypeOfSymbol(c, symbol), (current.parent as QualifiedName).right.text);
+    symbol = getPropertyOfType(c, getTypeOfSymbol(c, symbol), getText((current.parent as QualifiedName).right));
     if (symbol === undefined) return undefined;
     current = current.parent!;
   }

package/src/compiler/checker-type-factory.ts

@@ -8,6 +8,7 @@ import { getAliasForTypeNode, getTypeArgumentsOfDeferredReference } from './chec
 import { TypeSystemPropertyName, popTypeResolution, pushTypeResolution } from './checker-symbols.js';
 import { isGenericIndexType } from './checker-type-operators.js';
 import { compareCodePoints } from './diagnostics.js';
+import { utf8Length } from './character-codes.js';
 import { Diagnostics } from './diagnostic-messages.js';
 import type { Checker } from './checker.js';
 import {
@@ -79,6 +80,7 @@ import { addOptionality } from './checker-symbol-types.js';
 import { getSourceFileOfNode } from './binder-utilities.js';
 import { isPartOfTypeNode } from './transformers/alias-references.js';
 import { CheckFlags, declarationCount, getSymbolId, type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
+import { comparePseudoBigInts } from './pseudo-bigint.js';
 
 export const enum UnionReduction {
   None = 0,
@@ -500,6 +502,9 @@ export function compareNodes(c: Checker, n1: Node | undefined, n2: Node | undefi
   if (n1 === n2) return 0;
   if (n1 === undefined) return 1;
   if (n2 === undefined) return -1;
+  // Siblings are in one file: most compared declarations are members of one declaration.
+  const parent = n1.parent;
+  if (parent !== undefined && parent === n2.parent) return n1.pos - n2.pos;
   const s1 = sourceFileOf(n1);
   const s2 = sourceFileOf(n2);
   if (s1 !== s2) return (c.fileIndex.get(s1) ?? 0) - (c.fileIndex.get(s2) ?? 0);
@@ -562,11 +567,12 @@ function getTypeNameSymbol(t: Type): Symbol | undefined {
 function compareTypeNames(c: Checker, t1: Type, t2: Type): number {
   const s1 = getTypeNameSymbol(t1);
   const s2 = getTypeNameSymbol(t2);
-  if (s1 === s2)
-    return t1.alias !== undefined ? compareTypeLists(c, t1.alias.typeArguments, t2.alias!.typeArguments) : 0;
+  if (s1 === s2) return compareTypeLists(c, t1.alias?.typeArguments, t2.alias?.typeArguments);
   if (s1 === undefined) return 1;
   if (s2 === undefined) return -1;
-  return compareCodePoints(s1.name, s2.name);
+  const r = compareCodePoints(s1.name, s2.name);
+  // Distinct declarations with the same name stay together before alias arguments or structure decide.
+  return r !== 0 ? r : compareSymbols(c, s1, s2);
 }
 
 function compareTypeLists(c: Checker, s1: readonly Type[] | undefined, s2: readonly Type[] | undefined): number {
@@ -800,8 +806,17 @@ export function compareTypes(c: Checker, t1: Type, t2: Type): number {
   if ((flags & TypeFlags.Singleton) !== 0) {
     // Only distinguished by ids.
   } else if ((flags & TypeFlags.Object) !== 0) {
-    r = compareSymbols(c, t1.symbol, t2.symbol);
-    if (r !== 0) return r;
+    if ((t1.objectFlags & t2.objectFlags & ObjectFlags.InstantiationExpressionType) !== 0) {
+      // Instantiation expression types are ordered by their source declaration, since one expression
+      // can produce a type for each union constituent, then by the expression, without symbol ids.
+      r = compareNodes(c, t1.symbol?.declaration, t2.symbol?.declaration);
+      if (r !== 0) return r;
+      r = compareNodes(c, (t1 as InstantiationExpressionType).node, (t2 as InstantiationExpressionType).node);
+      if (r !== 0) return r;
+    } else {
+      r = compareSymbols(c, t1.symbol, t2.symbol);
+      if (r !== 0) return r;
+    }
     if ((t1.objectFlags & ObjectFlags.Reference) !== 0 && (t2.objectFlags & ObjectFlags.Reference) !== 0) {
       const r1 = t1 as TypeReference;
       const r2 = t2 as TypeReference;
@@ -823,9 +838,28 @@ export function compareTypes(c: Checker, t1: Type, t2: Type): number {
     } else if ((t1.objectFlags & ObjectFlags.Reference) !== 0) return -1;
     else if ((t2.objectFlags & ObjectFlags.Reference) !== 0) return 1;
     else {
+      // Unnamed non-reference object types are ordered by kind and instantiation data.
       r = (t1.objectFlags & ObjectFlags.ObjectTypeKindMask) - (t2.objectFlags & ObjectFlags.ObjectTypeKindMask);
       if (r !== 0) return r;
-      r = compareTypeMappers(c, (t1 as ObjectType).mapper, (t2 as ObjectType).mapper);
+      if ((t1.objectFlags & ObjectFlags.ReverseMapped) !== 0) {
+        const r1 = t1 as ReverseMappedType;
+        const r2 = t2 as ReverseMappedType;
+        r = compareTypes(c, r1.source!, r2.source!);
+        if (r !== 0) return r;
+        r = compareTypes(c, r1.mappedType!, r2.mappedType!);
+        if (r !== 0) return r;
+        r = compareTypes(c, r1.constraintType!, r2.constraintType!);
+        if (r !== 0) return r;
+      }
+      let m1 = (t1 as ObjectType).mapper;
+      let m2 = (t2 as ObjectType).mapper;
+      if ((t1.objectFlags & ObjectFlags.Mapped) !== 0) {
+        // instantiateAnonymousType prepends a mapping to a fresh type parameter; compare the
+        // instantiation itself rather than the identity of that parameter.
+        if (m1 instanceof CompositeTypeMapper) m1 = m1.m2;
+        if (m2 instanceof CompositeTypeMapper) m2 = m2.m2;
+      }
+      r = compareTypeMappers(c, m1, m2);
       if (r !== 0) return r;
     }
   } else if ((flags & TypeFlags.Union) !== 0) {
@@ -852,6 +886,9 @@ export function compareTypes(c: Checker, t1: Type, t2: Type): number {
   } else if ((flags & TypeFlags.NumberLiteral) !== 0) {
     r = compareNumbers((t1 as LiteralType).numberValue, (t2 as LiteralType).numberValue);
     if (r !== 0) return r;
+  } else if ((flags & TypeFlags.BigIntLiteral) !== 0) {
+    r = comparePseudoBigInts((t1 as LiteralType).stringValue, (t2 as LiteralType).stringValue);
+    if (r !== 0) return r;
   } else if ((flags & TypeFlags.BooleanLiteral) !== 0) {
     const b1 = (t1 as LiteralType).stringValue === 'true';
     const b2 = (t2 as LiteralType).stringValue === 'true';
@@ -1108,7 +1145,30 @@ export function filterType(c: Checker, type: Type, f: (t: Type) => boolean): Typ
 }
 
 export function removeType(c: Checker, type: Type, target: Type): Type {
-  return filterType(c, type, (t) => t !== target);
+  if ((type.flags & TypeFlags.Union) === 0) return type === target ? c.neverType : type;
+  const union = type as UnionType;
+  const origin = union.origin;
+  // An origin that lists the target keeps the rest of its constituents.
+  if (
+    origin !== undefined &&
+    (origin.flags & TypeFlags.Union) !== 0 &&
+    containsType(c, (origin as UnionType).types, target)
+  )
+    return filterType(c, type, (t) => t !== target);
+  const types = union.types;
+  const index =
+    types.length < linearTypeSearchLimit ? indexOfType(types, target, 0) : binarySearchTypes(c, types, target);
+  if (index < 0) return type;
+  if (types.length === 2) return types[1 - index]!;
+  const filtered: Type[] = [];
+  for (let i = 0; i < types.length; i++) if (i !== index) filtered.push(types[i]!);
+  return getUnionTypeFromSortedList(
+    c,
+    filtered,
+    union.objectFlags & (ObjectFlags.PrimitiveUnion | ObjectFlags.ContainsIntersections),
+    undefined,
+    undefined,
+  );
 }
 
 export function countTypes(type: Type): number {
@@ -1973,21 +2033,26 @@ function intersectUnionsOfPrimitiveTypes(c: Checker, types: Type[]): boolean {
 }
 
 function eachUnionContains(c: Checker, unionTypes: Type[], t: Type): boolean {
-  for (const type of unionTypes) {
-    const u = type as UnionType;
-    if (unionContainsType(c, u, t)) continue;
-    if (t === c.missingType) return unionContainsType(c, u, c.undefinedType);
-    if (t === c.undefinedType) return unionContainsType(c, u, c.missingType);
-    let primitive: Type | undefined;
-    if ((t.flags & TypeFlags.StringLiteral) !== 0) primitive = c.stringType;
-    else if ((t.flags & (TypeFlags.Enum | TypeFlags.NumberLiteral)) !== 0) primitive = c.numberType;
-    else if ((t.flags & TypeFlags.BigIntLiteral) !== 0) primitive = c.bigintType;
-    else if ((t.flags & TypeFlags.UniqueESSymbol) !== 0) primitive = c.esSymbolType;
-    if (primitive === undefined || !unionContainsType(c, u, primitive)) return false;
-  }
+  for (const type of unionTypes) if (!unionContainsTypeOrPrimitive(c, type as UnionType, t, true)) return false;
   return true;
 }
 
+/**
+ * Whether `union` contains `t`, `undefined` where `t` is the missing type and the other way around, or
+ * the primitive type of literal `t` (of a unique symbol only with `matchSymbol`).
+ */
+export function unionContainsTypeOrPrimitive(c: Checker, union: UnionType, t: Type, matchSymbol: boolean): boolean {
+  if (unionContainsType(c, union, t)) return true;
+  if (t === c.missingType) return unionContainsType(c, union, c.undefinedType);
+  if (t === c.undefinedType) return unionContainsType(c, union, c.missingType);
+  let primitive: Type | undefined;
+  if ((t.flags & TypeFlags.StringLiteral) !== 0) primitive = c.stringType;
+  else if ((t.flags & (TypeFlags.Enum | TypeFlags.NumberLiteral)) !== 0) primitive = c.numberType;
+  else if ((t.flags & TypeFlags.BigIntLiteral) !== 0) primitive = c.bigintType;
+  else if ((t.flags & TypeFlags.UniqueESSymbol) !== 0 && matchSymbol) primitive = c.esSymbolType;
+  return primitive !== undefined && unionContainsType(c, union, primitive);
+}
+
 export function getCrossProductUnionSize(types: readonly Type[]): number {
   let size = 1;
   for (const t of types) {
@@ -2553,7 +2618,13 @@ export function getTemplateLiteralType(c: Checker, texts: string[], types: Type[
   }
   if (types.includes(c.wildcardType)) return c.wildcardType;
   const builder = new TemplateBuilder(c, texts[0]!);
-  if (!builder.addSpans(texts, types)) return c.stringType;
+  if (!builder.addSpans(texts, types)) {
+    if (builder.tooLarge) {
+      c.error(c.currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
+      return c.errorType;
+    }
+    return c.stringType;
+  }
   if (builder.newTypes.length === 0) return getStringLiteralType(c, builder.text);
   builder.newTexts.push(builder.text);
   const newTexts = builder.newTexts;
@@ -2572,15 +2643,30 @@ export function getTemplateLiteralType(c: Checker, texts: string[], types: Type[
   return type;
 }
 
+/**
+ * Limits on the size of a template literal type that getTemplateLiteralType builds, in UTF-8 bytes of text
+ * and in placeholders. Recursive instantiations such as `Recur<any, `${S}_${S}`>` double the text or the
+ * placeholders on every step and exhaust memory long before the tail recursion limit of conditional types.
+ */
+const maxTemplateLiteralTypeLength = 50_000_000;
+const maxTemplateLiteralTypeSpans = 100_000;
+
 class TemplateBuilder {
   readonly c: Checker;
   text: string;
   readonly newTypes: Type[] = [];
   readonly newTexts: string[] = [];
+  /** UTF-8 bytes of `text`. */
+  private textBytes: number;
+  /** UTF-8 bytes of the texts already moved into `newTexts`. */
+  private movedBytes = 0;
+  /** Whether `addSpans` stopped because the result passed a size limit. */
+  tooLarge = false;
 
   constructor(c: Checker, text: string) {
     this.c = c;
     this.text = text;
+    this.textBytes = utf8Length(text);
   }
 
   addSpans(texts: string[], types: Type[]): boolean {
@@ -2588,17 +2674,30 @@ class TemplateBuilder {
     for (let i = 0; i < types.length; i++) {
       const t = types[i]!;
       if ((t.flags & (TypeFlags.Literal | TypeFlags.Null | TypeFlags.Undefined)) !== 0) {
-        this.text += getTemplateStringForType(c, t) + texts[i + 1]!;
+        const added = getTemplateStringForType(c, t) + texts[i + 1]!;
+        this.text += added;
+        this.textBytes += utf8Length(added);
       } else if ((t.flags & TypeFlags.TemplateLiteral) !== 0) {
         const template = t as TemplateLiteralType;
         this.text += template.texts[0]!;
+        this.textBytes += utf8Length(template.texts[0]!);
         if (!this.addSpans(template.texts, template.types)) return false;
         this.text += texts[i + 1]!;
+        this.textBytes += utf8Length(texts[i + 1]!);
       } else if (isGenericIndexType(c, t) || isPatternLiteralPlaceholderType(c, t)) {
         this.newTypes.push(t);
         this.newTexts.push(this.text);
+        this.movedBytes += this.textBytes;
         this.text = texts[i + 1]!;
+        this.textBytes = utf8Length(this.text);
       } else return false;
+      if (
+        this.movedBytes + this.textBytes > maxTemplateLiteralTypeLength ||
+        this.newTypes.length > maxTemplateLiteralTypeSpans
+      ) {
+        this.tooLarge = true;
+        return false;
+      }
     }
     return true;
   }