Make type comparison error elaboration consistent (#58859)

Author: gabritto

src/compiler/checker.ts

@@ -21464,7 +21464,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
         const id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol);
         const entry = enumRelation.get(id);
-        if (entry !== undefined && !(!(entry & RelationComparisonResult.Reported) && entry & RelationComparisonResult.Failed && errorReporter)) {
+        if (entry !== undefined && !(entry & RelationComparisonResult.Failed && errorReporter)) {
             return !!(entry & RelationComparisonResult.Succeeded);
         }
         const targetEnumType = getTypeOfSymbol(targetSymbol);
@@ -21474,11 +21474,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 if (!targetProperty || !(targetProperty.flags & SymbolFlags.EnumMember)) {
                     if (errorReporter) {
                         errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(sourceProperty), typeToString(getDeclaredTypeOfSymbol(targetSymbol), /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType));
-                        enumRelation.set(id, RelationComparisonResult.Failed | RelationComparisonResult.Reported);
-                    }
-                    else {
-                        enumRelation.set(id, RelationComparisonResult.Failed);
                     }
+                    enumRelation.set(id, RelationComparisonResult.Failed);
                     return false;
                 }
                 const sourceValue = getEnumMemberValue(getDeclarationOfKind(sourceProperty, SyntaxKind.EnumMember)!).value;
@@ -21489,15 +21486,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
                     // If we have 2 enums with *known* values that differ, they are incompatible.
                     if (sourceValue !== undefined && targetValue !== undefined) {
-                        if (!errorReporter) {
-                            enumRelation.set(id, RelationComparisonResult.Failed);
-                        }
-                        else {
+                        if (errorReporter) {
                             const escapedSource = sourceIsString ? `"${escapeString(sourceValue)}"` : sourceValue;
                             const escapedTarget = targetIsString ? `"${escapeString(targetValue)}"` : targetValue;
                             errorReporter(Diagnostics.Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given, symbolName(targetSymbol), symbolName(targetProperty), escapedTarget, escapedSource);
-                            enumRelation.set(id, RelationComparisonResult.Failed | RelationComparisonResult.Reported);
                         }
+                        enumRelation.set(id, RelationComparisonResult.Failed);
                         return false;
                     }
 
@@ -21508,16 +21502,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     // Either way, we can assume that it's numeric.
                     // If the other is a string, we have a mismatch in types.
                     if (sourceIsString || targetIsString) {
-                        if (!errorReporter) {
-                            enumRelation.set(id, RelationComparisonResult.Failed);
-                        }
-                        else {
+                        if (errorReporter) {
                             const knownStringValue = sourceValue ?? targetValue;
                             Debug.assert(typeof knownStringValue === "string");
                             const escapedValue = `"${escapeString(knownStringValue)}"`;
                             errorReporter(Diagnostics.One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value, symbolName(targetSymbol), symbolName(targetProperty), escapedValue);
-                            enumRelation.set(id, RelationComparisonResult.Failed | RelationComparisonResult.Reported);
                         }
+                        enumRelation.set(id, RelationComparisonResult.Failed);
                         return false;
                     }
                 }
@@ -21716,7 +21707,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         if (overflow) {
             // Record this relation as having failed such that we don't attempt the overflowing operation again.
             const id = getRelationKey(source, target, /*intersectionState*/ IntersectionState.None, relation, /*ignoreConstraints*/ false);
-            relation.set(id, RelationComparisonResult.Reported | RelationComparisonResult.Failed);
+            relation.set(id, RelationComparisonResult.Failed | (relationCount <= 0 ? RelationComparisonResult.ComplexityOverflow : RelationComparisonResult.StackDepthOverflow));
             tracing?.instant(tracing.Phase.CheckTypes, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: sourceDepth, targetDepth });
             const message = relationCount <= 0 ?
                 Diagnostics.Excessive_complexity_comparing_types_0_and_1 :
@@ -22617,9 +22608,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             const id = getRelationKey(source, target, intersectionState, relation, /*ignoreConstraints*/ false);
             const entry = relation.get(id);
             if (entry !== undefined) {
-                if (reportErrors && entry & RelationComparisonResult.Failed && !(entry & RelationComparisonResult.Reported)) {
-                    // We are elaborating errors and the cached result is an unreported failure. The result will be reported
-                    // as a failure, and should be updated as a reported failure by the bottom of this function.
+                if (reportErrors && entry & RelationComparisonResult.Failed && !(entry & RelationComparisonResult.Overflow)) {
+                    // We are elaborating errors and the cached result is a failure not due to a comparison overflow,
+                    // so we will do the comparison again to generate an error message.
                 }
                 else {
                     if (outofbandVarianceMarkerHandler) {
@@ -22632,6 +22623,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                             instantiateType(source, reportUnreliableMapper);
                         }
                     }
+                    if (reportErrors && entry & RelationComparisonResult.Overflow) {
+                        const message = entry & RelationComparisonResult.ComplexityOverflow ?
+                            Diagnostics.Excessive_complexity_comparing_types_0_and_1 :
+                            Diagnostics.Excessive_stack_depth_comparing_types_0_and_1;
+                        reportError(message, typeToString(source), typeToString(target));
+                        overrideNextErrorInfo++;
+                    }
                     return entry & RelationComparisonResult.Succeeded ? Ternary.True : Ternary.False;
                 }
             }
@@ -22735,7 +22733,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             else {
                 // A false result goes straight into global cache (when something is false under
                 // assumptions it will also be false without assumptions)
-                relation.set(id, (reportErrors ? RelationComparisonResult.Reported : 0) | RelationComparisonResult.Failed | propagatingVarianceFlags);
+                relation.set(id, RelationComparisonResult.Failed | propagatingVarianceFlags);
                 relationCount--;
                 resetMaybeStack(/*markAllAsSucceeded*/ false);
             }

src/compiler/types.ts

@@ -913,11 +913,14 @@ export const enum RelationComparisonResult {
     None                = 0,
     Succeeded           = 1 << 0, // Should be truthy
     Failed              = 1 << 1,
-    Reported            = 1 << 2,
 
     ReportsUnmeasurable = 1 << 3,
     ReportsUnreliable   = 1 << 4,
     ReportsMask         = ReportsUnmeasurable | ReportsUnreliable,
+
+    ComplexityOverflow  = 1 << 5,
+    StackDepthOverflow  = 1 << 6,
+    Overflow            = ComplexityOverflow | StackDepthOverflow,
 }
 
 /** @internal */

tests/baselines/reference/arrayFrom.errors.txt

@@ -1,6 +1,7 @@
 arrayFrom.ts(20,7): error TS2322: Type 'A[]' is not assignable to type 'B[]'.
   Property 'b' is missing in type 'A' but required in type 'B'.
 arrayFrom.ts(23,7): error TS2322: Type 'A[]' is not assignable to type 'B[]'.
+  Property 'b' is missing in type 'A' but required in type 'B'.
 
 
 ==== arrayFrom.ts (2 errors) ====
@@ -33,6 +34,8 @@ arrayFrom.ts(23,7): error TS2322: Type 'A[]' is not assignable to type 'B[]'.
     const result6: B[] = Array.from(inputALike); // expect error
           ~~~~~~~
 !!! error TS2322: Type 'A[]' is not assignable to type 'B[]'.
+!!! error TS2322:   Property 'b' is missing in type 'A' but required in type 'B'.
+!!! related TS2728 arrayFrom.ts:9:3: 'b' is declared here.
     const result7: B[] = Array.from(inputALike, ({ a }): B => ({ b: a }));
     const result8: A[] = Array.from(inputARand);
     const result9: B[] = Array.from(inputARand, ({ a }): B => ({ b: a }));

tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt

@@ -3,7 +3,7 @@ arrayOfSubtypeIsAssignableToReadonlyArray.ts(13,1): error TS2322: Type 'A[]' is
 arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error TS2322: Type 'C<A>' is not assignable to type 'readonly B[]'.
   The types returned by 'concat(...)' are incompatible between these types.
     Type 'A[]' is not assignable to type 'B[]'.
-      Type 'A' is not assignable to type 'B'.
+      Property 'b' is missing in type 'A' but required in type 'B'.
 
 
 ==== arrayOfSubtypeIsAssignableToReadonlyArray.ts (2 errors) ====
@@ -33,5 +33,6 @@ arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error TS2322: Type 'C<A>' is
 !!! error TS2322: Type 'C<A>' is not assignable to type 'readonly B[]'.
 !!! error TS2322:   The types returned by 'concat(...)' are incompatible between these types.
 !!! error TS2322:     Type 'A[]' is not assignable to type 'B[]'.
-!!! error TS2322:       Type 'A' is not assignable to type 'B'.
+!!! error TS2322:       Property 'b' is missing in type 'A' but required in type 'B'.
+!!! related TS2728 arrayOfSubtypeIsAssignableToReadonlyArray.ts:2:21: 'b' is declared here.
 

tests/baselines/reference/assignmentCompatWithNumericIndexer.errors.txt

@@ -11,15 +11,15 @@ assignmentCompatWithNumericIndexer.ts(32,9): error TS2322: Type '{ [x: number]:
 assignmentCompatWithNumericIndexer.ts(33,9): error TS2322: Type 'A<T>' is not assignable to type '{ [x: number]: Derived; }'.
   'number' index signatures are incompatible.
     Type 'T' is not assignable to type 'Derived'.
-      Type 'Base' is not assignable to type 'Derived'.
+      Property 'bar' is missing in type 'Base' but required in type 'Derived'.
 assignmentCompatWithNumericIndexer.ts(36,9): error TS2322: Type '{ [x: number]: Derived2; }' is not assignable to type 'A<T>'.
   'number' index signatures are incompatible.
     Type 'Derived2' is not assignable to type 'T'.
       'Derived2' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'Base'.
 assignmentCompatWithNumericIndexer.ts(37,9): error TS2322: Type 'A<T>' is not assignable to type '{ [x: number]: Derived2; }'.
   'number' index signatures are incompatible.
     Type 'T' is not assignable to type 'Derived2'.
-      Type 'Base' is not assignable to type 'Derived2'.
+      Type 'Base' is missing the following properties from type 'Derived2': baz, bar
 
 
 ==== assignmentCompatWithNumericIndexer.ts (6 errors) ====
@@ -74,7 +74,8 @@ assignmentCompatWithNumericIndexer.ts(37,9): error TS2322: Type 'A<T>' is not as
 !!! error TS2322: Type 'A<T>' is not assignable to type '{ [x: number]: Derived; }'.
 !!! error TS2322:   'number' index signatures are incompatible.
 !!! error TS2322:     Type 'T' is not assignable to type 'Derived'.
-!!! error TS2322:       Type 'Base' is not assignable to type 'Derived'.
+!!! error TS2322:       Property 'bar' is missing in type 'Base' but required in type 'Derived'.
+!!! related TS2728 assignmentCompatWithNumericIndexer.ts:4:34: 'bar' is declared here.
 
             var b2: { [x: number]: Derived2; }
             a = b2; // error
@@ -88,7 +89,7 @@ assignmentCompatWithNumericIndexer.ts(37,9): error TS2322: Type 'A<T>' is not as
 !!! error TS2322: Type 'A<T>' is not assignable to type '{ [x: number]: Derived2; }'.
 !!! error TS2322:   'number' index signatures are incompatible.
 !!! error TS2322:     Type 'T' is not assignable to type 'Derived2'.
-!!! error TS2322:       Type 'Base' is not assignable to type 'Derived2'.
+!!! error TS2322:       Type 'Base' is missing the following properties from type 'Derived2': baz, bar
 
             var b3: { [x: number]: T; }
             a = b3; // ok

tests/baselines/reference/assignmentCompatWithNumericIndexer2.errors.txt

@@ -11,15 +11,15 @@ assignmentCompatWithNumericIndexer2.ts(32,9): error TS2322: Type '{ [x: number]:
 assignmentCompatWithNumericIndexer2.ts(33,9): error TS2322: Type 'A<T>' is not assignable to type '{ [x: number]: Derived; }'.
   'number' index signatures are incompatible.
     Type 'T' is not assignable to type 'Derived'.
-      Type 'Base' is not assignable to type 'Derived'.
+      Property 'bar' is missing in type 'Base' but required in type 'Derived'.
 assignmentCompatWithNumericIndexer2.ts(36,9): error TS2322: Type '{ [x: number]: Derived2; }' is not assignable to type 'A<T>'.
   'number' index signatures are incompatible.
     Type 'Derived2' is not assignable to type 'T'.
       'Derived2' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'Base'.
 assignmentCompatWithNumericIndexer2.ts(37,9): error TS2322: Type 'A<T>' is not assignable to type '{ [x: number]: Derived2; }'.
   'number' index signatures are incompatible.
     Type 'T' is not assignable to type 'Derived2'.
-      Type 'Base' is not assignable to type 'Derived2'.
+      Type 'Base' is missing the following properties from type 'Derived2': baz, bar
 
 
 ==== assignmentCompatWithNumericIndexer2.ts (6 errors) ====
@@ -74,7 +74,8 @@ assignmentCompatWithNumericIndexer2.ts(37,9): error TS2322: Type 'A<T>' is not a
 !!! error TS2322: Type 'A<T>' is not assignable to type '{ [x: number]: Derived; }'.
 !!! error TS2322:   'number' index signatures are incompatible.
 !!! error TS2322:     Type 'T' is not assignable to type 'Derived'.
-!!! error TS2322:       Type 'Base' is not assignable to type 'Derived'.
+!!! error TS2322:       Property 'bar' is missing in type 'Base' but required in type 'Derived'.
+!!! related TS2728 assignmentCompatWithNumericIndexer2.ts:4:34: 'bar' is declared here.
 
             var b2: { [x: number]: Derived2; }
             a = b2; // error
@@ -88,7 +89,7 @@ assignmentCompatWithNumericIndexer2.ts(37,9): error TS2322: Type 'A<T>' is not a
 !!! error TS2322: Type 'A<T>' is not assignable to type '{ [x: number]: Derived2; }'.
 !!! error TS2322:   'number' index signatures are incompatible.
 !!! error TS2322:     Type 'T' is not assignable to type 'Derived2'.
-!!! error TS2322:       Type 'Base' is not assignable to type 'Derived2'.
+!!! error TS2322:       Type 'Base' is missing the following properties from type 'Derived2': baz, bar
 
             var b3: { [x: number]: T; }
             a = b3; // ok