Fix invariant generic error elaboration logic

ahejlsberg · ahejlsberg · commit a287ddc93bda · 2017-11-06T09:25:41.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -9432,6 +9432,7 @@ namespace ts {
 
             function structuredTypeRelatedTo(source: Type, target: Type, reportErrors: boolean): Ternary {
                 let result: Ternary;
+                let originalErrorInfo: DiagnosticMessageChain;
                 const saveErrorInfo = errorInfo;
                 if (target.flags & TypeFlags.TypeParameter) {
                     // A source type { [P in keyof T]: X } is related to a target type T if X is related to T[P].
@@ -9511,6 +9512,7 @@ namespace ts {
                         // if we have indexed access types with identical index types, see if relationship holds for
                         // the two object types.
                         if (result = isRelatedTo((<IndexedAccessType>source).objectType, (<IndexedAccessType>target).objectType, reportErrors)) {
+                            errorInfo = saveErrorInfo;
                             return result;
                         }
                     }
@@ -9542,6 +9544,10 @@ namespace ts {
                             if (!(reportErrors && some(variances, v => v === Variance.Invariant))) {
                                 return Ternary.False;
                             }
+                            // We remember the original error information so we can restore it in case the structural
+                            // comparison unexpectedly succeeds. This can happen when the structural comparison result
+                            // is a Ternary.Maybe for example caused by the recursion depth limiter.
+                            originalErrorInfo = errorInfo;
                             errorInfo = saveErrorInfo;
                         }
                     }
@@ -9580,8 +9586,11 @@ namespace ts {
                             }
                         }
                         if (result) {
-                            errorInfo = saveErrorInfo;
-                            return result;
+                            if (!originalErrorInfo) {
+                                errorInfo = saveErrorInfo;
+                                return result;
+                            }
+                            errorInfo = originalErrorInfo;
                         }
                     }
                 }

Original file line number	Diff line number	Diff line change
`@@ -9432,6 +9432,7 @@ namespace ts {`
`9432`	`9432`
`9433`	`9433`	`function structuredTypeRelatedTo(source: Type, target: Type, reportErrors: boolean): Ternary {`
`9434`	`9434`	`let result: Ternary;`
	`9435`	`+ let originalErrorInfo: DiagnosticMessageChain;`
`9435`	`9436`	`const saveErrorInfo = errorInfo;`
`9436`	`9437`	`if (target.flags & TypeFlags.TypeParameter) {`
`9437`	`9438`	`// A source type { [P in keyof T]: X } is related to a target type T if X is related to T[P].`
`@@ -9511,6 +9512,7 @@ namespace ts {`
`9511`	`9512`	`// if we have indexed access types with identical index types, see if relationship holds for`
`9512`	`9513`	`// the two object types.`
`9513`	`9514`	`if (result = isRelatedTo((<IndexedAccessType>source).objectType, (<IndexedAccessType>target).objectType, reportErrors)) {`
	`9515`	`+ errorInfo = saveErrorInfo;`
`9514`	`9516`	`return result;`
`9515`	`9517`	`}`
`9516`	`9518`	`}`
`@@ -9542,6 +9544,10 @@ namespace ts {`
`9542`	`9544`	`if (!(reportErrors && some(variances, v => v === Variance.Invariant))) {`
`9543`	`9545`	`return Ternary.False;`
`9544`	`9546`	`}`
	`9547`	`+ // We remember the original error information so we can restore it in case the structural`
	`9548`	`+ // comparison unexpectedly succeeds. This can happen when the structural comparison result`
	`9549`	`+ // is a Ternary.Maybe for example caused by the recursion depth limiter.`
	`9550`	`+ originalErrorInfo = errorInfo;`
`9545`	`9551`	`errorInfo = saveErrorInfo;`
`9546`	`9552`	`}`
`9547`	`9553`	`}`
`@@ -9580,8 +9586,11 @@ namespace ts {`
`9580`	`9586`	`}`
`9581`	`9587`	`}`
`9582`	`9588`	`if (result) {`
`9583`		`- errorInfo = saveErrorInfo;`
`9584`		`- return result;`
	`9589`	`+ if (!originalErrorInfo) {`
	`9590`	`+ errorInfo = saveErrorInfo;`
	`9591`	`+ return result;`
	`9592`	`+ }`
	`9593`	`+ errorInfo = originalErrorInfo;`
`9585`	`9594`	`}`
`9586`	`9595`	`}`
`9587`	`9596`	`}`