tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/relations.js

@@ -7,9 +7,9 @@ import { getCombinedModifierFlags } from './binder-utilities.js';
 import { Diagnostic, messageElidedInCompatibilityPyramid } from './diagnostics.js';
 import { isContextSensitive } from './checker-functions.js';
 import { createDiagnosticForNode } from './checker.js';
-import { cachedTypeKey, emptyTypes, newTypeMapper, SimpleTypeMapper, } from './checker-types.js';
+import { cachedTypeKey, emptyTypes, newTypeMapper, SimpleTypeMapper, isDistributedTypeParameter, } from './checker-types.js';
 import { createInferenceContext, inferTypes } from './checker-inference.js';
-import { unionContainsSortedTypes, unionContainsType, createArrayTypeEx, compareTypes, containsMissingType, createTypeReference, everyType, filterType, getBaseTypeOfLiteralType, getBaseTypeOfEnumLikeType, getElementTypes, getIntersectionType, getIntersectionTypeEx, getTargetType, getTypeArguments, getTypeReferenceArity, getUnionType, getUnionTypeEx, isArrayOrTupleType, isArrayType, isEmptyAnonymousObjectType, isEmptyObjectType, isErrorType, isFreshLiteralType, isGenericTupleType, isLiteralType, isMutableArrayOrTuple, isReadonlyArrayType, isTupleType, isUnitType, someType, tupleTargetOf, typesOf, countTypes, getStartElementCount, getEndElementCount, createNormalizedTypeReference, typeListKey, getRegularTypeOfLiteralType, } from './checker-type-factory.js';
+import { unionContainsSortedTypes, unionContainsType, createArrayTypeEx, compareTypes, containsMissingType, createTypeReference, everyType, filterType, getBaseTypeOfLiteralType, getBaseTypeOfEnumLikeType, getElementTypes, getIntersectionType, getIntersectionTypeEx, getTargetType, getTypeArguments, getTypeReferenceArity, getUnionType, getUnionTypeEx, isArrayOrTupleType, isArrayType, isEmptyAnonymousObjectType, isEmptyObjectType, isErrorType, isFreshLiteralType, isGenericTupleType, isLiteralType, isMutableArrayOrTuple, isReadonlyArrayType, isTupleType, isUnitType, someType, tupleTargetOf, typesOf, countTypes, getStartElementCount, getEndElementCount, createNormalizedTypeReference, typeListKey, getRegularTypeOfLiteralType, compareSymbols, } from './checker-type-factory.js';
 import { findApplicableIndexInfo, getApparentType, getApplicableIndexInfo, getApplicableIndexInfoForName, getBaseConstraintOfType, getBaseConstraintOrType, getConstraintOfType, getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertiesOfUnionOrIntersectionType, getPropertyOfObjectType, getPropertyOfType, getPropertyOfUnionOrIntersectionType, getReducedType, getSignaturesOfStructuredType, getSignaturesOfType, getTargetSymbol, getTypeOfPropertyOfType, getTypeWithThisArgument, getUnionOrIntersectionProperty, isApplicableIndexType, isArrayLikeType, isObjectLiteralType, isDiscriminantWithNeverType, isConflictingPrivateProperty, resolveStructuredTypeMembers, getResolvedMember, hasResolvedProperties, resolvedPropertiesAreOptional, positionsOfNamesFoundInSource, firstUnmatchedProperty, } from './checker-members.js';
 import { getParentOfSymbol, getMergedSymbol, getMembersOfSymbol, getSpellingSuggestionForName, } from './checker-symbols.js';
 import { CodePoints, distanceToCandidate, utf8Length } from './spelling.js';
@@ -45,6 +45,7 @@ export class Relation {
                 return 0 /* RelationComparisonResult.None */;
         }
     }
+    /** Sets the result of `key`, and returns whether the key is new. */
     set(key, result) {
         const keys = this.keys;
         const mask = keys.length - 1;
@@ -52,7 +53,7 @@ export class Relation {
             const k = keys[i];
             if (k === key) {
                 this.results[i] = result;
-                return;
+                return false;
             }
             if (k === 0) {
                 keys[i] = key;
@@ -60,10 +61,32 @@ export class Relation {
                 this.count++;
                 if (this.count * 4 > keys.length * 3)
                     this.grow();
-                return;
+                return true;
             }
         }
     }
+    /** Removes `key`, moving later entries of its probe run back so lookups still find them. */
+    delete(key) {
+        const keys = this.keys;
+        const results = this.results;
+        const mask = keys.length - 1;
+        let i = relationSlot(key) & mask;
+        for (; keys[i] !== key; i = (i + 1) & mask)
+            if (keys[i] === 0)
+                return;
+        for (let j = (i + 1) & mask; keys[j] !== 0; j = (j + 1) & mask) {
+            // An entry stays where it is when its home slot is cyclically after the freed slot and at or before it.
+            const home = relationSlot(keys[j]) & mask;
+            if (i <= j ? i < home && home <= j : i < home || home <= j)
+                continue;
+            keys[i] = keys[j];
+            results[i] = results[j];
+            i = j;
+        }
+        keys[i] = 0;
+        results[i] = 0;
+        this.count--;
+    }
     size() {
         return this.count;
     }
@@ -232,6 +255,16 @@ export function isTypeRelatedTo(c, source, target, relation) {
         if ((source.flags & 394239 /* TypeFlags.Singleton */) !== 0)
             return true;
     }
+    else {
+        // What the relater decides first for types that may simplify (Relater.isRelatedToEx): their normal forms are
+        // one type, or can be identical only with identical flags.
+        const s = getNormalizedType(c, source, false);
+        const t = getNormalizedType(c, target, true);
+        if (s === t)
+            return true;
+        if (s.flags !== t.flags)
+            return false;
+    }
     if ((source.flags & 1048576 /* TypeFlags.Object */) !== 0 && (target.flags & 1048576 /* TypeFlags.Object */) !== 0) {
         const related = relation.get(getRelationKey(c, source, target, 0 /* IntersectionState.None */, relation === c.identityRelation, false).key);
         if (related !== 0 /* RelationComparisonResult.None */)
@@ -423,15 +456,15 @@ function isEnumTypeRelatedTo(c, source, target, reporter) {
         const targetProperty = getPropertyOfType(c, targetEnumType, sourceProperty.name);
         if (targetProperty === undefined || (targetProperty.flags & 8 /* SymbolFlags.EnumMember */) === 0) {
             if (reporter !== undefined)
-                reporter.reportError(502 /* Diagnostics.Property_0_is_missing_in_type_1 */, [
+                reporter.reportError(509 /* Diagnostics.Property_0_is_missing_in_type_1 */, [
                     symbolToString(c, sourceProperty),
                     typeToString(c, getDeclaredTypeOfSymbol(c, targetSymbol), undefined, 1 << 6),
                 ]);
             c.enumRelation.set(key, 2 /* RelationComparisonResult.Failed */);
             return false;
         }
-        const sourceDecl = getDeclarations(sourceProperty).find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
-        const targetDecl = getDeclarations(targetProperty).find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
+        const sourceDecl = getDeclarations(sourceProperty).find((d) => d.kind === 307 /* SyntaxKind.EnumMember */);
+        const targetDecl = getDeclarations(targetProperty).find((d) => d.kind === 307 /* SyntaxKind.EnumMember */);
         if (sourceDecl === undefined || targetDecl === undefined)
             continue;
         computeEnumMemberValues(c, sourceDecl.parent);
@@ -445,7 +478,7 @@ function isEnumTypeRelatedTo(c, source, target, reporter) {
             continue;
         if (s.enumValueKind !== 0 && t.enumValueKind !== 0) {
             if (reporter !== undefined)
-                reporter.reportError(1111 /* Diagnostics.Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given */, [
+                reporter.reportError(1118 /* Diagnostics.Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given */, [
                     symbolToString(c, targetSymbol),
                     symbolToString(c, targetProperty),
                     enumValueText(t.enumValueKind, t.enumNumberValue, t.enumStringValue),
@@ -458,7 +491,7 @@ function isEnumTypeRelatedTo(c, source, target, reporter) {
         if (s.enumValueKind === 2 || t.enumValueKind === 2) {
             if (reporter !== undefined) {
                 const known = s.enumValueKind === 2 ? s : t;
-                reporter.reportError(1112 /* Diagnostics.One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value */, [symbolToString(c, targetSymbol), symbolToString(c, targetProperty), JSON.stringify(known.enumStringValue)]);
+                reporter.reportError(1119 /* Diagnostics.One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value */, [symbolToString(c, targetSymbol), symbolToString(c, targetProperty), JSON.stringify(known.enumStringValue)]);
             }
             c.enumRelation.set(key, 2 /* RelationComparisonResult.Failed */);
             return false;
@@ -613,20 +646,35 @@ export function checkTypeRelatedTo(c, source, target, relation, errorNode, headM
     // Nested checks (from resolving types during the relation) find no spare and allocate their own.
     const r = c.spareRelater ?? new Relater(c, relation, errorNode);
     c.spareRelater = undefined;
+    const relationCount = Math.trunc((16000000 - relation.size()) / 8);
+    if (errorNode !== undefined) {
+        // Relate without reporting first: reporting builds a message for every comparison that fails on the way,
+        // even when the relation holds. When the relation fails, the results this pass added are removed, since
+        // the comparisons it assumed related while comparing would change which failure the report elaborates.
+        r.reset(relation, undefined);
+        r.relationCount = relationCount;
+        const addedKeys = [];
+        r.addedKeys = addedKeys;
+        const quiet = r.isRelatedToEx(source, target, 3 /* RecursionFlags.Both */, false, undefined, 0 /* IntersectionState.None */);
+        r.addedKeys = undefined;
+        if (quiet !== 0 /* Ternary.False */ && !r.overflow) {
+            c.spareRelater = r;
+            return true;
+        }
+        for (const key of addedKeys)
+            relation.delete(key);
+    }
     r.reset(relation, errorNode);
-    r.relationCount = Math.trunc((16000000 - relation.size()) / 8);
+    r.relationCount = relationCount;
     const result = r.isRelatedToEx(source, target, 3 /* RecursionFlags.Both */, errorNode !== undefined, headMessage, 0 /* IntersectionState.None */);
     if (r.overflow) {
         // Remember the overflow so it isn't attempted again.
         const key = getRelationKey(c, source, target, 0 /* IntersectionState.None */, relation === c.identityRelation, false).key;
-        relation.set(key, 2 /* RelationComparisonResult.Failed */ |
-            (r.relationCount <= 0
-                ? 32 /* RelationComparisonResult.ComplexityOverflow */
-                : 64 /* RelationComparisonResult.StackDepthOverflow */));
-        const message = r.relationCount <= 0
-            ? 979 /* Diagnostics.Excessive_complexity_comparing_types_0_and_1 */
-            : 499 /* Diagnostics.Excessive_stack_depth_comparing_types_0_and_1 */;
-        reportDiagnostic(c, createDiagnosticForNode(errorNode ?? c.currentNode, message, [typeToString(c, source), typeToString(c, target)]), diagnosticOutput);
+        relation.set(key, 2 /* RelationComparisonResult.Failed */ | 32 /* RelationComparisonResult.ComplexityOverflow */);
+        reportDiagnostic(c, createDiagnosticForNode(errorNode ?? c.currentNode, 986 /* Diagnostics.Excessive_complexity_comparing_types_0_and_1 */, [
+            typeToString(c, source),
+            typeToString(c, target),
+        ]), diagnosticOutput);
     }
     else if (r.errorChain !== undefined) {
         const diagnostic = createDiagnosticFromErrorChain(r.errorChain, r.errorNode, r.relatedInfo);
@@ -709,14 +757,14 @@ function addToDottedName(head, tail) {
     return suffix.startsWith('[') ? prefix + head + suffix : prefix + head + '.' + suffix;
 }
 function isConversionOrInterfaceImplementationMessage(message) {
-    return (message === 591 /* Diagnostics.Class_0_incorrectly_implements_interface_1 */ ||
+    return (message === 598 /* Diagnostics.Class_0_incorrectly_implements_interface_1 */ ||
         message ===
-            852 /* Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass */ ||
+            859 /* Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass */ ||
         message ===
-            528 /* Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first */ ||
-        message === 920 /* Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element */ ||
-        message === 919 /* Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element */ ||
-        message === 921 /* Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element */);
+            535 /* Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first */ ||
+        message === 927 /* Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element */ ||
+        message === 926 /* Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element */ ||
+        message === 928 /* Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element */);
 }
 // ---- The relater
 /** The state of a relation check: its error chain, maybe-stack and recursion stacks. */
@@ -736,6 +784,8 @@ export class Relater extends TypeComparer {
     expandingFlags = 0 /* ExpandingFlags.None */;
     overflow = false;
     relationCount = 0;
+    /** The keys this check added to the relation, while relating without reporting first. */
+    addedKeys = undefined;
     /** The intersection state passed to `compare` during signature comparisons. */
     signatureIntersectionState = 0 /* IntersectionState.None */;
     // What `relateVariances` changes in its caller's state when it falls back to structure.
@@ -858,9 +908,9 @@ export class Relater extends TypeComparer {
                         (constructs.length > 0 &&
                             this.isRelatedTo(getReturnTypeOfSignature(c, constructs[0]), target, 1 /* RecursionFlags.Source */, false) !==
                                 0 /* Ternary.False */))
-                        this.reportError(714 /* Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it */, [sourceString, targetString]);
+                        this.reportError(721 /* Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it */, [sourceString, targetString]);
                     else
-                        this.reportError(713 /* Diagnostics.Type_0_has_no_properties_in_common_with_type_1 */, [sourceString, targetString]);
+                        this.reportError(720 /* Diagnostics.Type_0_has_no_properties_in_common_with_type_1 */, [sourceString, targetString]);
                 }
                 return 0 /* Ternary.False */;
             }
@@ -909,25 +959,25 @@ export class Relater extends TypeComparer {
                     // Report in terms of the object types we check in isKnownProperty, at the property.
                     const errorTarget = filterType(c, reducedTarget, isExcessPropertyCheckTarget);
                     const errorNode = this.errorNode;
-                    if (errorNode.kind === 293 /* SyntaxKind.JsxAttributes */ ||
+                    if (errorNode.kind === 294 /* SyntaxKind.JsxAttributes */ ||
                         isJsxOpeningLikeElement(errorNode) ||
                         (errorNode.parent !== undefined && isJsxOpeningLikeElement(errorNode.parent))) {
                         // Attributes are checked like object literals but reported as attributes, at the attribute.
                         const valueDeclaration = prop.valueDeclaration;
                         if (valueDeclaration !== undefined &&
-                            valueDeclaration.kind === 292 /* SyntaxKind.JsxAttribute */ &&
+                            valueDeclaration.kind === 293 /* SyntaxKind.JsxAttribute */ &&
                             sameFile(valueDeclaration, errorNode))
                             this.errorNode = getName(valueDeclaration);
                         const propName = symbolToString(c, prop);
                         const suggestion = getSuggestedSymbolForNonexistentJSXAttribute(c, propName, errorTarget);
                         if (suggestion !== undefined)
-                            this.reportError(706 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2 */, [
+                            this.reportError(713 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2 */, [
                                 propName,
                                 typeToString(c, errorTarget),
                                 symbolToString(c, suggestion),
                             ]);
                         else
-                            this.reportError(516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
+                            this.reportError(523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
                                 propName,
                                 typeToString(c, errorTarget),
                             ]);
@@ -949,16 +999,16 @@ export class Relater extends TypeComparer {
                             suggestion = getSpellingSuggestionForName(c, getText(name), getPropertiesOfType(c, errorTarget), 111551 /* SymbolFlags.Value */);
                     }
                     if (suggestion !== undefined)
-                        this.reportError(715 /* Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2 */, [symbolToString(c, prop), typeToString(c, errorTarget), suggestion.name]);
+                        this.reportError(722 /* Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2 */, [symbolToString(c, prop), typeToString(c, errorTarget), suggestion.name]);
                     else
-                        this.reportError(529 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */, [symbolToString(c, prop), typeToString(c, errorTarget)]);
+                        this.reportError(536 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */, [symbolToString(c, prop), typeToString(c, errorTarget)]);
                 }
                 return true;
             }
             if (checkTypes !== undefined &&
                 this.isRelatedTo(getTypeOfSymbol(c, prop), getTypeOfPropertyInTypes(c, checkTypes, prop.name), 3 /* RecursionFlags.Both */, reportErrors) === 0 /* Ternary.False */) {
                 if (reportErrors)
-                    this.reportError(504 /* Diagnostics.Types_of_property_0_are_incompatible */, [symbolToString(c, prop)]);
+                    this.reportError(511 /* Diagnostics.Types_of_property_0_are_incompatible */, [symbolToString(c, prop)]);
                 return true;
             }
         }
@@ -1125,18 +1175,17 @@ export class Relater extends TypeComparer {
         if (entry !== 0 /* RelationComparisonResult.None */) {
             if (reportErrors &&
                 (entry & 2 /* RelationComparisonResult.Failed */) !== 0 &&
-                (entry & 96 /* RelationComparisonResult.Overflow */) === 0) {
+                (entry & 32 /* RelationComparisonResult.Overflow */) === 0) {
                 // Redo the failed comparison to elaborate.
             }
             else {
                 c.reliabilityFlags |=
                     entry & (8 /* RelationComparisonResult.ReportsUnmeasurable */ | 16 /* RelationComparisonResult.ReportsUnreliable */);
-                if (reportErrors && (entry & 96 /* RelationComparisonResult.Overflow */) !== 0) {
-                    const message = (entry & 32 /* RelationComparisonResult.ComplexityOverflow */) !== 0
-                        ? 979 /* Diagnostics.Excessive_complexity_comparing_types_0_and_1 */
-                        : 499 /* Diagnostics.Excessive_stack_depth_comparing_types_0_and_1 */;
-                    this.reportError(message, [typeToString(c, source), typeToString(c, target)]);
-                }
+                if (reportErrors && (entry & 32 /* RelationComparisonResult.Overflow */) !== 0)
+                    this.reportError(986 /* Diagnostics.Excessive_complexity_comparing_types_0_and_1 */, [
+                        typeToString(c, source),
+                        typeToString(c, target),
+                    ]);
                 return (entry & 1 /* RelationComparisonResult.Succeeded */) !== 0 ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
             }
         }
@@ -1154,10 +1203,10 @@ export class Relater extends TypeComparer {
         }
         const sourceDepth = this.sourceDepth;
         const targetDepth = this.targetDepth;
-        if (sourceDepth === 100 || targetDepth === 100) {
-            this.overflow = true;
-            return 0 /* Ternary.False */;
-        }
+        // A backstop for infinite recursion that isDeeplyNestedType misses, which also stops relating the exceedingly
+        // rare types that are truly more than 100 levels deep.
+        if (sourceDepth === 100 || targetDepth === 100)
+            return 3 /* Ternary.Maybe */;
         const maybeStart = this.maybeKeys.length;
         this.maybeKeys.push(id);
         this.maybeKeysSet.add(id);
@@ -1194,17 +1243,21 @@ export class Relater extends TypeComparer {
         }
         else {
             // False under assumptions is false without them.
-            this.relation.set(id, 2 /* RelationComparisonResult.Failed */ | propagatingVarianceFlags);
+            this.record(id, 2 /* RelationComparisonResult.Failed */ | propagatingVarianceFlags);
             this.relationCount--;
             this.resetMaybeStack(maybeStart, propagatingVarianceFlags, false);
         }
         return result;
     }
+    record(key, result) {
+        if (this.relation.set(key, result) && this.addedKeys !== undefined)
+            this.addedKeys.push(key);
+    }
     resetMaybeStack(maybeStart, propagatingVarianceFlags, markAllAsSucceeded) {
         for (let i = maybeStart; i < this.maybeKeys.length; i++) {
             this.maybeKeysSet.delete(this.maybeKeys[i]);
             if (markAllAsSucceeded) {
-                this.relation.set(this.maybeKeys[i], 1 /* RelationComparisonResult.Succeeded */ | propagatingVarianceFlags);
+                this.record(this.maybeKeys[i], 1 /* RelationComparisonResult.Succeeded */ | propagatingVarianceFlags);
                 this.relationCount--;
             }
         }
@@ -1897,7 +1950,7 @@ export class Relater extends TypeComparer {
                         ? this.isRelatedTo(s, t, 3 /* RecursionFlags.Both */, false)
                         : compareTypesIdentical(c, s, t);
             else {
-                if (c.inVarianceComputation && (varianceFlags & 16 /* VarianceFlags.Unreliable */) !== 0)
+                if (c.varianceStack.length !== 0 && (varianceFlags & 16 /* VarianceFlags.Unreliable */) !== 0)
                     instantiateType(c, s, c.reportUnreliableMapper);
                 if (variance === 1 /* VarianceFlags.Covariant */)
                     related = this.isRelatedToEx(s, t, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
@@ -1958,33 +2011,34 @@ export class Relater extends TypeComparer {
                 const sourceArity = getTypeReferenceArity(source);
                 const targetArity = getTypeReferenceArity(target);
                 const sourceRest = isTupleType(source) ? (tupleTargetOf(source).combinedFlags & 4 /* ElementFlags.Rest */) !== 0 : true;
-                const targetHasRestElement = (targetTuple.combinedFlags & 12 /* ElementFlags.Variable */) !== 0;
+                const targetHasRestElement = (targetTuple.combinedFlags & 4 /* ElementFlags.Rest */) !== 0;
+                const targetHasVariableElement = (targetTuple.combinedFlags & 12 /* ElementFlags.Variable */) !== 0;
                 const sourceMinLength = isTupleType(source) ? tupleTargetOf(source).minLength : 0;
                 const targetMinLength = targetTuple.minLength;
                 if (!sourceRest && sourceArity < targetMinLength) {
                     if (reportErrors)
-                        this.reportError(762 /* Diagnostics.Source_has_0_element_s_but_target_requires_1 */, [
+                        this.reportError(769 /* Diagnostics.Source_has_0_element_s_but_target_requires_1 */, [
                             String(sourceArity),
                             String(targetMinLength),
                         ]);
                     return 0 /* Ternary.False */;
                 }
-                if (!targetHasRestElement && targetArity < sourceMinLength) {
+                if (!targetHasVariableElement && targetArity < sourceMinLength) {
                     if (reportErrors)
-                        this.reportError(763 /* Diagnostics.Source_has_0_element_s_but_target_allows_only_1 */, [
+                        this.reportError(770 /* Diagnostics.Source_has_0_element_s_but_target_allows_only_1 */, [
                             String(sourceMinLength),
                             String(targetArity),
                         ]);
                     return 0 /* Ternary.False */;
                 }
-                if (!targetHasRestElement && (sourceRest || targetArity < sourceArity)) {
+                if (!targetHasVariableElement && (sourceRest || targetArity < sourceArity)) {
                     if (reportErrors) {
                         if (sourceMinLength < targetMinLength)
-                            this.reportError(764 /* Diagnostics.Target_requires_0_element_s_but_source_may_have_fewer */, [
+                            this.reportError(771 /* Diagnostics.Target_requires_0_element_s_but_source_may_have_fewer */, [
                                 String(targetMinLength),
                             ]);
                         else
-                            this.reportError(765 /* Diagnostics.Target_allows_only_0_element_s_but_source_may_have_more */, [
+                            this.reportError(772 /* Diagnostics.Target_allows_only_0_element_s_but_source_may_have_more */, [
                                 String(targetArity),
                             ]);
                     }
@@ -2000,25 +2054,34 @@ export class Relater extends TypeComparer {
                         ? tupleTargetOf(source).elementInfos[sourcePosition].flags
                         : 4 /* ElementFlags.Rest */;
                     const sourcePositionFromEnd = sourceArity - 1 - sourcePosition;
-                    const targetPosition = targetHasRestElement && sourcePosition >= targetStartCount
+                    const restMapped = targetHasRestElement && sourcePosition >= targetStartCount;
+                    // A source element past the target's last element (a target with variadic but no rest elements).
+                    if (!restMapped && sourcePosition >= targetArity) {
+                        if (reportErrors)
+                            this.reportError(772 /* Diagnostics.Target_allows_only_0_element_s_but_source_may_have_more */, [
+                                String(targetArity),
+                            ]);
+                        return 0 /* Ternary.False */;
+                    }
+                    const targetPosition = restMapped
                         ? targetArity - 1 - Math.min(sourcePositionFromEnd, targetEndCount)
                         : sourcePosition;
                     const targetFlags = targetPosition >= 0 ? targetTuple.elementInfos[targetPosition].flags : 0 /* ElementFlags.None */;
                     if ((targetFlags & 8 /* ElementFlags.Variadic */) !== 0 && (sourceFlags & 8 /* ElementFlags.Variadic */) === 0) {
                         if (reportErrors)
-                            this.reportError(767 /* Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target */, [
+                            this.reportError(774 /* Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target */, [
                                 String(targetPosition),
                             ]);
                         return 0 /* Ternary.False */;
                     }
                     if ((sourceFlags & 8 /* ElementFlags.Variadic */) !== 0 && (targetFlags & 12 /* ElementFlags.Variable */) === 0) {
                         if (reportErrors)
-                            this.reportError(768 /* Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target */, [String(sourcePosition), String(targetPosition)]);
+                            this.reportError(775 /* Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target */, [String(sourcePosition), String(targetPosition)]);
                         return 0 /* Ternary.False */;
                     }
                     if ((targetFlags & 1 /* ElementFlags.Required */) !== 0 && (sourceFlags & 1 /* ElementFlags.Required */) === 0) {
                         if (reportErrors)
-                            this.reportError(766 /* Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target */, [
+                            this.reportError(773 /* Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target */, [
                                 String(targetPosition),
                             ]);
                         return 0 /* Ternary.False */;
@@ -2041,9 +2104,9 @@ export class Relater extends TypeComparer {
                                 sourcePosition >= targetStartCount &&
                                 sourcePositionFromEnd >= targetEndCount &&
                                 targetStartCount !== sourceArity - targetEndCount - 1)
-                                this.reportError(770 /* Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target */, [String(targetStartCount), String(sourceArity - targetEndCount - 1), String(targetPosition)]);
+                                this.reportError(777 /* Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target */, [String(targetStartCount), String(sourceArity - targetEndCount - 1), String(targetPosition)]);
                             else
-                                this.reportError(769 /* Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target */, [String(sourcePosition), String(targetPosition)]);
+                                this.reportError(776 /* Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target */, [String(sourcePosition), String(targetPosition)]);
                         }
                         return 0 /* Ternary.False */;
                     }
@@ -2075,7 +2138,7 @@ export class Relater extends TypeComparer {
                     continue;
                 if (getPropertyOfObjectType(c, target, sourceProp.name) === undefined) {
                     if (reportErrors)
-                        this.reportError(516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
+                        this.reportError(523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
                             symbolToString(c, sourceProp),
                             typeToString(c, target),
                         ]);
@@ -2114,12 +2177,12 @@ export class Relater extends TypeComparer {
             if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
                 if (reportErrors) {
                     if ((sourcePropFlags & 2 /* ModifierFlags.Private */) !== 0 && (targetPropFlags & 2 /* ModifierFlags.Private */) !== 0)
-                        this.reportError(610 /* Diagnostics.Types_have_separate_declarations_of_a_private_property_0 */, [
+                        this.reportError(617 /* Diagnostics.Types_have_separate_declarations_of_a_private_property_0 */, [
                             symbolToString(c, targetProp),
                         ]);
                     else {
                         const sourceIsPrivate = (sourcePropFlags & 2 /* ModifierFlags.Private */) !== 0;
-                        this.reportError(503 /* Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2 */, [
+                        this.reportError(510 /* Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2 */, [
                             symbolToString(c, targetProp),
                             typeToString(c, sourceIsPrivate ? source : target),
                             typeToString(c, sourceIsPrivate ? target : source),
@@ -2132,7 +2195,7 @@ export class Relater extends TypeComparer {
         else if ((targetPropFlags & 4 /* ModifierFlags.Protected */) !== 0) {
             if (!isValidOverrideOf(c, sourceProp, targetProp)) {
                 if (reportErrors)
-                    this.reportError(611 /* Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2 */, [
+                    this.reportError(618 /* Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2 */, [
                         symbolToString(c, targetProp),
                         typeToString(c, getDeclaringClass(c, sourceProp) ?? source),
                         typeToString(c, getDeclaringClass(c, targetProp) ?? target),
@@ -2142,7 +2205,7 @@ export class Relater extends TypeComparer {
         }
         else if ((sourcePropFlags & 4 /* ModifierFlags.Protected */) !== 0) {
             if (reportErrors)
-                this.reportError(612 /* Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2 */, [
+                this.reportError(619 /* Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2 */, [
                     symbolToString(c, targetProp),
                     typeToString(c, source),
                     typeToString(c, target),
@@ -2157,7 +2220,7 @@ export class Relater extends TypeComparer {
         const related = this.isPropertySymbolTypeRelated(sourceProp, targetProp, sourcePropType, reportErrors, intersectionState);
         if (related === 0 /* Ternary.False */) {
             if (reportErrors)
-                this.reportError(504 /* Diagnostics.Types_of_property_0_are_incompatible */, [symbolToString(c, targetProp)]);
+                this.reportError(511 /* Diagnostics.Types_of_property_0_are_incompatible */, [symbolToString(c, targetProp)]);
             return 0 /* Ternary.False */;
         }
         if (!skipOptional &&
@@ -2165,7 +2228,7 @@ export class Relater extends TypeComparer {
             (targetProp.flags & 106500 /* SymbolFlags.ClassMember */) !== 0 &&
             (targetProp.flags & 16777216 /* SymbolFlags.Optional */) === 0) {
             if (reportErrors)
-                this.reportError(505 /* Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2 */, [
+                this.reportError(512 /* Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2 */, [
                     symbolToString(c, targetProp),
                     typeToString(c, source),
                     typeToString(c, target),
@@ -2194,7 +2257,7 @@ export class Relater extends TypeComparer {
             (source.symbol.flags & 32 /* SymbolFlags.Class */) !== 0) {
             const description = getText(declarationName);
             if (getPropertyOfType(c, source, getSymbolNameForPrivateIdentifier(source.symbol, description)) !== undefined) {
-                this.reportError(1837 /* Diagnostics.Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2 */, [description, symbolToString(c, source.symbol), symbolToString(c, target.symbol)]);
+                this.reportError(1857 /* Diagnostics.Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2 */, [description, symbolToString(c, source.symbol), symbolToString(c, target.symbol)]);
                 return;
             }
         }
@@ -2202,25 +2265,25 @@ export class Relater extends TypeComparer {
         if (props.length === 1) {
             const names = getTypeNamesForErrorDisplay(c, source, target);
             const propName = symbolToString(c, unmatchedProperty);
-            this.reportError(873 /* Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2 */, [
+            this.reportError(880 /* Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2 */, [
                 propName,
                 names[0],
                 names[1],
             ]);
             if (declarationCount(unmatchedProperty) !== 0)
-                this.relatedInfo.push(createDiagnosticForNode(unmatchedProperty.declaration, 860 /* Diagnostics.X_0_is_declared_here */, [propName]));
+                this.relatedInfo.push(createDiagnosticForNode(unmatchedProperty.declaration, 867 /* Diagnostics.X_0_is_declared_here */, [propName]));
         }
         else if (this.tryElaborateArrayLikeErrors(source, target, false)) {
             const names = getTypeNamesForErrorDisplay(c, source, target);
             if (props.length > 5)
-                this.reportError(872 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more */, [
+                this.reportError(879 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more */, [
                     names[0],
                     names[1],
                     symbolNames(c, props.slice(0, 4)),
                     String(props.length - 4),
                 ]);
             else
-                this.reportError(871 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2 */, [
+                this.reportError(878 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2 */, [
                     names[0],
                     names[1],
                     symbolNames(c, props),
@@ -2233,7 +2296,7 @@ export class Relater extends TypeComparer {
         if (isTupleType(source)) {
             if (tupleTargetOf(source).readonly && isMutableArrayOrTuple(c, target)) {
                 if (reportErrors)
-                    this.reportError(1090 /* Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1 */, [
+                    this.reportError(1097 /* Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1 */, [
                         typeToString(c, source),
                         typeToString(c, target),
                     ]);
@@ -2243,7 +2306,7 @@ export class Relater extends TypeComparer {
         }
         if (isReadonlyArrayType(c, source) && isMutableArrayOrTuple(c, target)) {
             if (reportErrors)
-                this.reportError(1090 /* Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1 */, [
+                this.reportError(1097 /* Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1 */, [
                     typeToString(c, source),
                     typeToString(c, target),
                 ]);
@@ -2292,7 +2355,7 @@ export class Relater extends TypeComparer {
             const targetIsAbstract = (targetSignatures[0].flags & 8 /* SignatureFlags.Abstract */) !== 0;
             if (sourceIsAbstract && !targetIsAbstract) {
                 if (reportErrors)
-                    this.reportError(677 /* Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type */, []);
+                    this.reportError(684 /* Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type */, []);
                 return 0 /* Ternary.False */;
             }
             if (!this.constructorVisibilitiesAreCompatible(sourceSignatures[0], targetSignatures[0], reportErrors))
@@ -2335,7 +2398,7 @@ export class Relater extends TypeComparer {
                     shouldElaborateErrors = false;
                 }
                 if (shouldElaborateErrors)
-                    this.reportError(792 /* Diagnostics.Type_0_provides_no_match_for_the_signature_1 */, [
+                    this.reportError(799 /* Diagnostics.Type_0_provides_no_match_for_the_signature_1 */, [
                         typeToString(c, source),
                         signatureToString(c, t),
                     ]);
@@ -2356,7 +2419,7 @@ export class Relater extends TypeComparer {
         if (targetAccessibility !== 4 /* ModifierFlags.Protected */ && sourceAccessibility === 0)
             return true;
         if (reportErrors)
-            this.reportError(806 /* Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type */, [
+            this.reportError(813 /* Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type */, [
                 visibilityToString(sourceAccessibility),
                 visibilityToString(targetAccessibility),
             ]);
@@ -2429,7 +2492,7 @@ export class Relater extends TypeComparer {
             isObjectTypeWithInferableIndex(c, source))
             return this.membersRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState);
         if (reportErrors)
-            this.reportError(507 /* Diagnostics.Index_signature_for_type_0_is_missing_in_type_1 */, [
+            this.reportError(514 /* Diagnostics.Index_signature_for_type_0_is_missing_in_type_1 */, [
                 typeToString(c, targetInfo.keyType),
                 typeToString(c, source),
             ]);
@@ -2457,7 +2520,7 @@ export class Relater extends TypeComparer {
             const related = this.isRelatedToEx(t, targetInfo.valueType, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
             if (related === 0 /* Ternary.False */) {
                 if (reportErrors)
-                    this.reportError(688 /* Diagnostics.Property_0_is_incompatible_with_index_signature */, [symbolToString(c, prop)]);
+                    this.reportError(695 /* Diagnostics.Property_0_is_incompatible_with_index_signature */, [symbolToString(c, prop)]);
                 return 0 /* Ternary.False */;
             }
             result &= related;
@@ -2477,9 +2540,9 @@ export class Relater extends TypeComparer {
         const related = this.isRelatedToEx(sourceInfo.valueType, targetInfo.valueType, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
         if (related === 0 /* Ternary.False */ && reportErrors) {
             if (sourceInfo.keyType === targetInfo.keyType)
-                this.reportError(777 /* Diagnostics.X_0_index_signatures_are_incompatible */, [typeToString(c, sourceInfo.keyType)]);
+                this.reportError(784 /* Diagnostics.X_0_index_signatures_are_incompatible */, [typeToString(c, sourceInfo.keyType)]);
             else
-                this.reportError(508 /* Diagnostics.X_0_and_1_index_signatures_are_incompatible */, [
+                this.reportError(515 /* Diagnostics.X_0_and_1_index_signatures_are_incompatible */, [
                     typeToString(c, sourceInfo.keyType),
                     typeToString(c, targetInfo.keyType),
                 ]);
@@ -2513,7 +2576,7 @@ export class Relater extends TypeComparer {
         if ((source.flags & 1048576 /* TypeFlags.Object */) !== 0 && (target.flags & 12713980 /* TypeFlags.Primitive */) !== 0)
             this.tryElaborateErrorsForPrimitivesAndObjects(source, target);
         else if (source.symbol !== undefined && (source.flags & 1048576 /* TypeFlags.Object */) !== 0 && c.globalObjectType === source)
-            this.reportError(828 /* Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead */, []);
+            this.reportError(835 /* Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead */, []);
         else if ((source.objectFlags & 2048 /* ObjectFlags.JsxAttributes */) !== 0 && (target.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
             // Attributes failing JSX.IntrinsicAttributes or JSX.IntrinsicClassAttributes report that member's error alone.
             const targetTypes = typesOf(target);
@@ -2528,7 +2591,7 @@ export class Relater extends TypeComparer {
         else if ((originalTarget.flags & 268435456 /* TypeFlags.Intersection */) !== 0 &&
             (lazyObjectFlags(c, originalTarget) & 67108864 /* ObjectFlags.IsNeverIntersection */) !== 0) {
             const props = getPropertiesOfUnionOrIntersectionType(c, originalTarget);
-            let message = 1848 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents */;
+            let message = 1868 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents */;
             let prop;
             for (const p of props) {
                 if (isDiscriminantWithNeverType(c, p)) {
@@ -2538,7 +2601,7 @@ export class Relater extends TypeComparer {
             }
             if (prop === undefined) {
                 message =
-                    1849 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some */;
+                    1869 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some */;
                 for (const p of props) {
                     if (isConflictingPrivateProperty(p)) {
                         prop = p;
@@ -2557,7 +2620,7 @@ export class Relater extends TypeComparer {
             const syntheticParam = cloneTypeParameter(c, source);
             syntheticParam.constraint = instantiateType(c, target, new SimpleTypeMapper(source, syntheticParam));
             if (hasNonCircularBaseConstraint(c, syntheticParam)) {
-                this.relatedInfo.push(createDiagnosticForNode(source.symbol.declaration, 473 /* Diagnostics.This_type_parameter_might_need_an_extends_0_constraint */, [typeToString(c, target)]));
+                this.relatedInfo.push(createDiagnosticForNode(source.symbol.declaration, 480 /* Diagnostics.This_type_parameter_might_need_an_extends_0_constraint */, [typeToString(c, target)]));
             }
         }
     }
@@ -2566,7 +2629,7 @@ export class Relater extends TypeComparer {
         if ((source === c.globalStringType && target === c.stringType) ||
             (source === c.globalNumberType && target === c.numberType) ||
             (source === c.globalBooleanType && target === c.booleanType))
-            this.reportError(824 /* Diagnostics.X_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible */, [
+            this.reportError(831 /* Diagnostics.X_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible */, [
                 typeToString(c, target),
                 typeToString(c, source),
             ]);
@@ -2592,14 +2655,20 @@ export class Relater extends TypeComparer {
             target !== c.markerSuperTypeForCheck &&
             target !== c.markerSubTypeForCheck) {
             const constraint = getBaseConstraintOfType(c, target);
-            if (constraint !== undefined && isTypeAssignableTo(c, generalizedSource, constraint))
-                this.reportError(1150 /* Diagnostics.X_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2 */, [generalizedSourceType, targetType, typeToString(c, constraint)]);
+            if (isDistributedTypeParameter(target) &&
+                isTypeAssignableTo(c, generalizedSource, target.constraint))
+                this.reportError(1192 /* Diagnostics.X_0_is_only_assignable_to_the_non_distributed_1_but_1_has_been_distributed_here */, [
+                    generalizedSourceType,
+                    targetType,
+                ]);
+            else if (constraint !== undefined && isTypeAssignableTo(c, generalizedSource, constraint))
+                this.reportError(1157 /* Diagnostics.X_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2 */, [generalizedSourceType, targetType, typeToString(c, constraint)]);
             else if (constraint !== undefined && isTypeAssignableTo(c, source, constraint))
-                this.reportError(1150 /* Diagnostics.X_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2 */, [sourceType, targetType, typeToString(c, constraint)]);
+                this.reportError(1157 /* Diagnostics.X_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2 */, [sourceType, targetType, typeToString(c, constraint)]);
             else {
                 // Reported once.
                 this.errorChain = undefined;
-                this.reportError(1157 /* Diagnostics.X_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1 */, [
+                this.reportError(1164 /* Diagnostics.X_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1 */, [
                     targetType,
                     generalizedSourceType,
                 ]);
@@ -2607,18 +2676,18 @@ export class Relater extends TypeComparer {
         }
         if (message === undefined) {
             if (this.relation === c.comparableRelation)
-                message = 812 /* Diagnostics.Type_0_is_not_comparable_to_type_1 */;
+                message = 819 /* Diagnostics.Type_0_is_not_comparable_to_type_1 */;
             else if (sourceType === targetType)
                 message =
-                    851 /* Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated */;
+                    858 /* Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated */;
             else if (c.exactOptionalPropertyTypes && getExactOptionalUnassignableProperties(c, source, target).length !== 0)
                 message =
-                    549 /* Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties */;
+                    556 /* Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties */;
             else {
                 if ((source.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 && (target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
                     const suggested = getSuggestedTypeForNonexistentStringLiteralType(c, source, target);
                     if (suggested !== undefined) {
-                        this.reportError(951 /* Diagnostics.Type_0_is_not_assignable_to_type_1_Did_you_mean_2 */, [
+                        this.reportError(958 /* Diagnostics.Type_0_is_not_assignable_to_type_1_Did_you_mean_2 */, [
                             generalizedSourceType,
                             targetType,
                             typeToString(c, suggested),
@@ -2626,32 +2695,31 @@ export class Relater extends TypeComparer {
                         return;
                     }
                 }
-                message = 500 /* Diagnostics.Type_0_is_not_assignable_to_type_1 */;
+                message = 507 /* Diagnostics.Type_0_is_not_assignable_to_type_1 */;
             }
         }
-        else if (message === 521 /* Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1 */ &&
+        else if (message === 528 /* Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1 */ &&
             c.exactOptionalPropertyTypes &&
             getExactOptionalUnassignableProperties(c, source, target).length !== 0)
             message =
-                553 /* Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties */;
+                560 /* Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties */;
         switch (this.getChainMessage(0)) {
             // Suppressed after an excess property error.
-            case 529 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */:
-            case 715 /* Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2 */:
+            case 536 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */:
+            case 722 /* Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2 */:
                 return;
-            case 979 /* Diagnostics.Excessive_complexity_comparing_types_0_and_1 */:
-            case 499 /* Diagnostics.Excessive_stack_depth_comparing_types_0_and_1 */:
-            case 1090 /* Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1 */:
+            case 986 /* Diagnostics.Excessive_complexity_comparing_types_0_and_1 */:
+            case 1097 /* Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1 */:
                 if (this.chainArgsMatch(generalizedSourceType, targetType, undefined))
                     return;
                 break;
-            case 873 /* Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2 */:
+            case 880 /* Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2 */:
                 if (!isConversionOrInterfaceImplementationMessage(message) &&
                     this.chainArgsMatch(undefined, generalizedSourceType, targetType))
                     return;
                 break;
-            case 872 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more */:
-            case 871 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2 */:
+            case 879 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more */:
+            case 878 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2 */:
                 if (!isConversionOrInterfaceImplementationMessage(message) &&
                     this.chainArgsMatch(generalizedSourceType, targetType, undefined))
                     return;
@@ -2660,44 +2728,44 @@ export class Relater extends TypeComparer {
         this.reportError(message, [generalizedSourceType, targetType]);
     }
     reportError(message, args) {
-        if (message === 504 /* Diagnostics.Types_of_property_0_are_incompatible */) {
+        if (message === 511 /* Diagnostics.Types_of_property_0_are_incompatible */) {
             switch (this.getChainMessage(0)) {
-                case 529 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */:
-                case 715 /* Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2 */:
+                case 536 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */:
+                case 722 /* Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2 */:
                     return;
             }
             // A property followed by a return type incompatibility becomes one message for `x()`.
             let arg = '';
             switch (this.getChainMessage(1)) {
-                case 469 /* Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */:
+                case 476 /* Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */:
                     arg = getPropertyNameArg(args[0]) + '()';
                     break;
-                case 470 /* Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */:
+                case 477 /* Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */:
                     arg = 'new ' + getPropertyNameArg(args[0]) + '()';
                     break;
-                case 467 /* Diagnostics.Call_signature_return_types_0_and_1_are_incompatible */:
+                case 474 /* Diagnostics.Call_signature_return_types_0_and_1_are_incompatible */:
                     arg = getPropertyNameArg(args[0]) + '(...)';
                     break;
-                case 468 /* Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible */:
+                case 475 /* Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible */:
                     arg = 'new ' + getPropertyNameArg(args[0]) + '(...)';
                     break;
             }
             if (arg !== '') {
-                message = 466 /* Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types */;
+                message = 473 /* Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types */;
                 args = [arg];
                 this.errorChain = this.errorChain.next.next;
             }
             // Nested property incompatibilities become one message for `x.y`.
             switch (this.getChainMessage(1)) {
-                case 504 /* Diagnostics.Types_of_property_0_are_incompatible */:
-                case 465 /* Diagnostics.The_types_of_0_are_incompatible_between_these_types */:
-                case 466 /* Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types */: {
+                case 511 /* Diagnostics.Types_of_property_0_are_incompatible */:
+                case 472 /* Diagnostics.The_types_of_0_are_incompatible_between_these_types */:
+                case 473 /* Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types */: {
                     const head = getPropertyNameArg(args[0]);
                     const tail = getPropertyNameArg(this.errorChain.next.args[0]);
                     const dotted = addToDottedName(head, tail);
                     this.errorChain = this.errorChain.next.next;
-                    if (message === 504 /* Diagnostics.Types_of_property_0_are_incompatible */)
-                        message = 465 /* Diagnostics.The_types_of_0_are_incompatible_between_these_types */;
+                    if (message === 511 /* Diagnostics.Types_of_property_0_are_incompatible */)
+                        message = 472 /* Diagnostics.The_types_of_0_are_incompatible_between_these_types */;
                     this.reportError(message, [dotted]);
                     return;
                 }
@@ -2775,7 +2843,7 @@ export function getSingleBaseForNonAugmentingSubtype(c, t) {
         const baseTypeNode = declaration !== undefined ? getExtendsHeritageClauseElement(declaration) : undefined;
         if (baseTypeNode !== undefined) {
             const expression = getExpression(baseTypeNode);
-            if (expression.kind !== 79 /* SyntaxKind.Identifier */ && expression.kind !== 212 /* SyntaxKind.PropertyAccessExpression */)
+            if (expression.kind !== 79 /* SyntaxKind.Identifier */ && expression.kind !== 213 /* SyntaxKind.PropertyAccessExpression */)
                 return undefined;
         }
     }
@@ -2912,12 +2980,12 @@ function isIgnoredJsxProperty(source, prop) {
 }
 function isObjectLiteralElement(node) {
     switch (node.kind) {
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-        case 305 /* SyntaxKind.SpreadAssignment */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 306 /* SyntaxKind.SpreadAssignment */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             return true;
     }
     return false;
@@ -3045,13 +3113,13 @@ export function isDiscriminantProperty(c, t, name) {
     const prop = getUnionOrIntersectionProperty(c, t, name, false);
     if (prop === undefined || (prop.checkFlags & 2 /* CheckFlags.SyntheticProperty */) === 0)
         return false;
-    if ((prop.checkFlags & 2097152 /* CheckFlags.IsDiscriminantComputed */) === 0) {
-        prop.checkFlags |= 2097152 /* CheckFlags.IsDiscriminantComputed */;
+    if ((prop.checkFlags & 16777216 /* CheckFlags.IsDiscriminantComputed */) === 0) {
+        prop.checkFlags |= 16777216 /* CheckFlags.IsDiscriminantComputed */;
         if ((prop.checkFlags & 192 /* CheckFlags.NonUniformAndLiteral */) === 192 /* CheckFlags.NonUniformAndLiteral */ &&
             !isGenericTypeLocal(c, getTypeOfSymbol(c, prop)))
-            prop.checkFlags |= 4194304 /* CheckFlags.IsDiscriminant */;
+            prop.checkFlags |= 33554432 /* CheckFlags.IsDiscriminant */;
     }
-    return (prop.checkFlags & 4194304 /* CheckFlags.IsDiscriminant */) !== 0;
+    return (prop.checkFlags & 33554432 /* CheckFlags.IsDiscriminant */) !== 0;
 }
 import { isGenericType as isGenericTypeLocal } from './checker-type-operators.js';
 /** The constituent selected by a key property's unit type; not computed yet. */
@@ -3269,14 +3337,14 @@ function contextFreeExpressionDeclaration(c, t) {
     if (declaration === undefined)
         return undefined;
     switch (declaration.kind) {
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 232 /* SyntaxKind.ClassExpression */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             return isContextSensitive(c, declaration) ? undefined : declaration;
     }
     return undefined;
@@ -3314,14 +3382,14 @@ export function setStackEntry(stack, depth, t) {
 export function isDeeplyNestedType(c, t, stack, depth, maxDepth) {
     if (depth < maxDepth)
         return false;
-    if ((t.objectFlags & 96 /* ObjectFlags.InstantiatedMapped */) === 96 /* ObjectFlags.InstantiatedMapped */ &&
-        (t.flags & 1048576 /* TypeFlags.Object */) !== 0)
-        t = getMappedTargetWithSymbol(c, t);
-    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0)
-        for (const u of typesOf(t))
+    const target = getRecursionIdentityTarget(c, t);
+    if ((target.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(target))
             if (isDeeplyNestedType(c, u, stack, depth, maxDepth))
                 return true;
-    const identity = getRecursionIdentity(t);
+        return false;
+    }
+    const identity = getRecursionIdentityFromTarget(target);
     let count = 0;
     let lastTypeId = 0;
     for (let i = 0; i < depth; i++) {
@@ -3337,8 +3405,64 @@ export function isDeeplyNestedType(c, t, stack, depth, maxDepth) {
     }
     return false;
 }
-function getMappedTargetWithSymbol(c, t) {
+/**
+ * isDeeplyNestedType for the newest entry of `stack[start..end)`, counting only the entries in that range.
+ * `identities` holds the recursion identity of each entry of the range once a check has computed it: 0 before
+ * that, and -1 for an entry whose recursion identity target is an intersection, which is matched by its
+ * constituents each time. Later checks compare the kept identities. The identities are computed when and in the
+ * order isDeeplyNestedType computes them, so the types and symbol ids they create come in the same order.
+ */
+export function isDeeplyNestedStackEntry(c, stack, identities, start, end, maxDepth) {
+    if (end - start < maxDepth)
+        return false;
+    return isDeeplyNestedInRange(c, stack[end - 1], true, stack, identities, start, end, maxDepth);
+}
+function isDeeplyNestedInRange(c, t, isEntry, stack, identities, start, end, maxDepth) {
+    const target = getRecursionIdentityTarget(c, t);
+    if ((target.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        if (isEntry)
+            identities[end - 1] = -1;
+        for (const u of typesOf(target))
+            if (isDeeplyNestedInRange(c, u, false, stack, identities, start, end, maxDepth))
+                return true;
+        return false;
+    }
+    const identity = getRecursionIdentityFromTarget(target);
+    if (isEntry)
+        identities[end - 1] = identity;
+    let count = 0;
+    let lastTypeId = 0;
+    for (let i = start; i < end; i++) {
+        const s = stack[i];
+        let known = identities[i];
+        if (known === 0) {
+            const sourceTarget = getRecursionIdentityTarget(c, s);
+            known = (sourceTarget.flags & 268435456 /* TypeFlags.Intersection */) !== 0 ? -1 : getRecursionIdentityFromTarget(sourceTarget);
+            identities[i] = known;
+        }
+        if (known >= 0 ? known === identity : hasMatchingRecursionIdentity(c, s, identity)) {
+            if (s.id >= lastTypeId) {
+                count++;
+                if (count >= maxDepth)
+                    return true;
+            }
+            lastTypeId = s.id;
+        }
+    }
+    return false;
+}
+/**
+ * The type whose recursion identity `t` has: the object type of an indexed access (T in T[K]), and for a
+ * homomorphic mapped type the deepest target type that has a symbol. Unwrapping mapped types keeps the identities of
+ * mapped types applied to written object literals unique: in `Mapped<{ x: Mapped<{ x: Mapped<{ x: string }>}>}>`,
+ * each application has the identity of its object literal and does not appear deeply nested.
+ */
+function getRecursionIdentityTarget(c, t) {
     for (;;) {
+        if ((t.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
+            t = t.objectType;
+            continue;
+        }
         if ((t.objectFlags & 96 /* ObjectFlags.InstantiatedMapped */) === 96 /* ObjectFlags.InstantiatedMapped */ &&
             (t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
             const target = getModifiersTypeFromMappedType(c, t);
@@ -3352,38 +3476,33 @@ function getMappedTargetWithSymbol(c, t) {
     }
 }
 function hasMatchingRecursionIdentity(c, t, identity) {
-    if ((t.objectFlags & 96 /* ObjectFlags.InstantiatedMapped */) === 96 /* ObjectFlags.InstantiatedMapped */ &&
-        (t.flags & 1048576 /* TypeFlags.Object */) !== 0)
-        t = getMappedTargetWithSymbol(c, t);
-    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
-        for (const u of typesOf(t))
+    const target = getRecursionIdentityTarget(c, t);
+    if ((target.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(target))
             if (hasMatchingRecursionIdentity(c, u, identity))
                 return true;
         return false;
     }
-    return getRecursionIdentity(t) === identity;
+    return getRecursionIdentityFromTarget(target) === identity;
 }
 /** An identity shared by instantiations of a type, so infinitely expanding instantiations can be detected. */
-export function getRecursionIdentity(t) {
+export function getRecursionIdentity(c, t) {
+    return getRecursionIdentityFromTarget(getRecursionIdentityTarget(c, t));
+}
+function getRecursionIdentityFromTarget(t) {
     if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
         (t.objectFlags & (128 /* ObjectFlags.ObjectLiteral */ | 16384 /* ObjectFlags.ArrayLiteral */)) === 0) {
         if ((t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && t.node !== undefined)
             return nodeRecursionId(t.node);
         if (t.symbol !== undefined &&
             !((t.objectFlags & 16 /* ObjectFlags.Anonymous */) !== 0 && (t.symbol.flags & 32 /* SymbolFlags.Class */) !== 0) &&
-            (t.objectFlags & 1073741824 /* ObjectFlags.FromTypeNode */) === 0)
+            (t.objectFlags & 536870912 /* ObjectFlags.FromTypeNode */) === 0)
             return symbolRecursionId(t.symbol);
-        if (isTupleType(t) && (t.objectFlags & 1073741824 /* ObjectFlags.FromTypeNode */) === 0)
+        if (isTupleType(t) && (t.objectFlags & 536870912 /* ObjectFlags.FromTypeNode */) === 0)
             return typeRecursionId(t.target);
     }
     if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 && t.symbol !== undefined)
         return symbolRecursionId(t.symbol);
-    if ((t.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
-        let objectType = t.objectType;
-        while ((objectType.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0)
-            objectType = objectType.objectType;
-        return typeRecursionId(objectType);
-    }
     if ((t.flags & 67108864 /* TypeFlags.Conditional */) !== 0)
         return nodeRecursionId(t.root.node);
     return typeRecursionId(t);
@@ -3414,17 +3533,50 @@ export function getAliasVariances(c, symbol) {
  * The measured variance of each type parameter, from relating marker instantiations; empty when
  * requested recursively.
  */
+/** A generic type whose variances are being computed. */
+export class VarianceStackEntry {
+    symbol;
+    typeParameters;
+    constructor(symbol, typeParameters) {
+        this.symbol = symbol;
+        this.typeParameters = typeParameters;
+    }
+}
 function getVariancesWorker(c, symbol, typeParameters) {
     const links = c.symbolLinks(symbol);
     if (links.variances !== undefined)
         return links.variances;
-    const oldVarianceComputation = c.inVarianceComputation;
+    let stackIndex = -1;
+    for (let i = 0; i < c.varianceStack.length; i++)
+        if (c.varianceStack[i].symbol === symbol) {
+            stackIndex = i;
+            break;
+        }
+    if (stackIndex >= 0) {
+        // A circularity. The variances computed can depend on where the circular region is entered, so the
+        // computation restarts from the generic type with the smallest symbol in the region if that is not this one,
+        // which keeps the results of circular generic types stable.
+        let minIndex = stackIndex;
+        for (let i = stackIndex + 1; i < c.varianceStack.length; i++)
+            if (compareSymbols(c, c.varianceStack[i].symbol, c.varianceStack[minIndex].symbol) < 0)
+                minIndex = i;
+        if (minIndex > stackIndex) {
+            const saveVarianceStack = c.varianceStack;
+            c.varianceStack = [];
+            getVariancesWorker(c, saveVarianceStack[minIndex].symbol, saveVarianceStack[minIndex].typeParameters);
+            c.varianceStack = saveVarianceStack;
+        }
+        // Variances that cannot be computed: the type parameters are treated as covariant. The computation in
+        // progress stores its results over this.
+        const stored = storedVariances(links);
+        if (stored === undefined || stored.length === 0)
+            links.variances = [];
+        return links.variances;
+    }
     const saveResolutionStart = c.resolutionStart;
-    if (!c.inVarianceComputation) {
-        c.inVarianceComputation = true;
+    if (c.varianceStack.length === 0)
         c.resolutionStart = c.resolutionDepth;
-    }
-    links.variances = [];
+    c.varianceStack.push(new VarianceStackEntry(symbol, typeParameters));
     const variances = [];
     for (const tp of typeParameters) {
         const modifiers = getTypeParameterModifiers(tp);
@@ -3451,14 +3603,24 @@ function getVariancesWorker(c, symbol, typeParameters) {
                 variance |= 16 /* VarianceFlags.Unreliable */;
             c.reliabilityFlags = saveReliabilityFlags;
         }
+        // A computation restarted because of a circularity may have stored the variances already.
+        const restarted = storedVariances(links);
+        if (restarted !== undefined && restarted.length !== 0)
+            break;
         variances.push(variance);
     }
-    if (!oldVarianceComputation) {
-        c.inVarianceComputation = false;
+    // Unless a restarted computation stored them.
+    const stored = storedVariances(links);
+    if (stored === undefined || stored.length === 0)
+        links.variances = variances;
+    c.varianceStack.pop();
+    if (c.varianceStack.length === 0)
         c.resolutionStart = saveResolutionStart;
-    }
-    links.variances = variances;
-    return variances;
+    return links.variances;
+}
+/** The variances stored in `links`, read again after computations that may have stored them. */
+function storedVariances(links) {
+    return links.variances;
 }
 export function createMarkerType(c, symbol, source, target) {
     const mapper = new SimpleTypeMapper(source, target);
@@ -3658,7 +3820,7 @@ export function compareSignaturesRelated(c, source, target, checkMode, reportErr
             : getMinArgumentCount(c, source) > targetCount);
     if (sourceHasMoreParameters) {
         if (reportErrors && (checkMode & 8 /* SignatureCheckMode.StrictArity */) === 0)
-            comparer.report(969 /* Diagnostics.Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1 */, [
+            comparer.report(976 /* Diagnostics.Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1 */, [
                 String(getMinArgumentCount(c, source)),
                 String(targetCount),
             ]);
@@ -3676,9 +3838,9 @@ export function compareSignaturesRelated(c, source, target, checkMode, reportErr
     const kind = target.declaration !== undefined ? target.declaration.kind : 0 /* SyntaxKind.Unknown */;
     const strictVariance = (checkMode & 3 /* SignatureCheckMode.Callback */) === 0 &&
         c.strictFunctionTypes &&
-        kind !== 175 /* SyntaxKind.MethodDeclaration */ &&
-        kind !== 174 /* SyntaxKind.MethodSignature */ &&
-        kind !== 177 /* SyntaxKind.Constructor */;
+        kind !== 176 /* SyntaxKind.MethodDeclaration */ &&
+        kind !== 175 /* SyntaxKind.MethodSignature */ &&
+        kind !== 178 /* SyntaxKind.Constructor */;
     let result = -1 /* Ternary.True */;
     const sourceThisType = getThisTypeOfSignature(c, source);
     if (sourceThisType !== undefined && sourceThisType !== c.voidType) {
@@ -3690,7 +3852,7 @@ export function compareSignaturesRelated(c, source, target, checkMode, reportErr
                 related = comparer.compare(targetThisType, sourceThisType, reportErrors);
             if (related === 0 /* Ternary.False */) {
                 if (reportErrors)
-                    comparer.report(818 /* Diagnostics.The_this_types_of_each_signature_are_incompatible */, []);
+                    comparer.report(825 /* Diagnostics.The_this_types_of_each_signature_are_incompatible */, []);
                 return 0 /* Ternary.False */;
             }
             result &= related;
@@ -3740,7 +3902,7 @@ export function compareSignaturesRelated(c, source, target, checkMode, reportErr
             related = 0 /* Ternary.False */;
         if (related === 0 /* Ternary.False */) {
             if (reportErrors)
-                comparer.report(506 /* Diagnostics.Types_of_parameters_0_and_1_are_incompatible */, [
+                comparer.report(513 /* Diagnostics.Types_of_parameters_0_and_1_are_incompatible */, [
                     getParameterNameAtPosition(c, source, i),
                     getParameterNameAtPosition(c, target, i),
                 ]);
@@ -3779,11 +3941,11 @@ export function compareSignaturesRelated(c, source, target, checkMode, reportErr
                 const construct = (source.flags & 4 /* SignatureFlags.Construct */) !== 0;
                 const message = source.parameters.length === 0 && target.parameters.length === 0
                     ? construct
-                        ? 470 /* Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */
-                        : 469 /* Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */
+                        ? 477 /* Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */
+                        : 476 /* Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */
                     : construct
-                        ? 468 /* Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible */
-                        : 467 /* Diagnostics.Call_signature_return_types_0_and_1_are_incompatible */;
+                        ? 475 /* Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible */
+                        : 474 /* Diagnostics.Call_signature_return_types_0_and_1_are_incompatible */;
                 comparer.report(message, [typeToString(c, sourceReturnType), typeToString(c, targetReturnType)]);
             }
         }
@@ -3799,7 +3961,7 @@ function isInstantiatedGenericParameter(c, signature, pos) {
 function compareTypePredicateRelatedTo(c, source, target, reportErrors, comparer) {
     if (source.kind !== target.kind) {
         if (reportErrors) {
-            comparer.report(678 /* Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard */, []);
+            comparer.report(685 /* Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard */, []);
             comparer.report(176 /* Diagnostics.Type_predicate_0_is_not_assignable_to_1 */, [
                 typePredicateToString(c, source),
                 typePredicateToString(c, target),
@@ -3976,6 +4138,7 @@ export function isExactOptionalPropertyMismatch(c, source, target) {
         containsMissingType(c, target));
 }
 /** The string literal member of `target` closest to the string literal `source`. */
+const maxStringLiteralSuggestionCandidates = 1000;
 function getSuggestedTypeForNonexistentStringLiteralType(c, source, target) {
     const value = source.stringValue;
     const valueCodePoints = new CodePoints();
@@ -3984,9 +4147,13 @@ function getSuggestedTypeForNonexistentStringLiteralType(c, source, target) {
     let bestDistance = Math.floor(valueCodePoints.length * 0.4) + 0.9;
     let best = undefined;
     const lowerValue = value.toLowerCase();
+    // A target with more string literal candidates than this gets no suggestion.
+    let candidates = 0;
     for (const t of typesOf(target)) {
         if ((t.flags & 1024 /* TypeFlags.StringLiteral */) === 0)
             continue;
+        if (++candidates > maxStringLiteralSuggestionCandidates)
+            return undefined;
         const name = t.stringValue;
         const nameLength = utf8Length(name);
         if (name === '' || Math.abs(nameLength - valueCodePoints.length) > maximumLengthDifference || name === value)