Fix tuple and array comparisons during identity checking (microsoft#32089)

weswigham · web-flow · commit 34eb5ddf75ad · 2019-06-25T20:56:41.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -13321,7 +13321,14 @@ namespace ts {
                         }
                     }
                     else if (isReadonlyArrayType(target) ? isArrayType(source) || isTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) {
-                        return isRelatedTo(getIndexTypeOfType(source, IndexKind.Number) || anyType, getIndexTypeOfType(target, IndexKind.Number) || anyType, reportErrors);
+                        if (relation !== identityRelation) {
+                            return isRelatedTo(getIndexTypeOfType(source, IndexKind.Number) || anyType, getIndexTypeOfType(target, IndexKind.Number) || anyType, reportErrors);
+                        }
+                        else {
+                            // By flags alone, we know that the `target` is a readonly array while the source is a normal array or tuple
+                            // or `target` is an array and source is a tuple - in both cases the types cannot be identical, by construction
+                            return Ternary.False;
+                        }
                     }
                     // Consider a fresh empty object literal type "closed" under the subtype relationship - this way `{} <- {[idx: string]: any} <- fresh({})`
                     // and not `{} <- fresh({}) <- {[idx: string]: any}`
diff --git a/tests/cases/fourslash/quickinfoExpressionTypeNotChangedViaDeletion.ts b/tests/cases/fourslash/quickinfoExpressionTypeNotChangedViaDeletion.ts
@@ -0,0 +1,15 @@
+/// <reference path="fourslash.ts" />
+////type TypeEq<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+////
+////const /*2*/test1: TypeEq<number[], [number, ...number[]]> = false;
+////
+////declare const foo: [number, ...number[]];
+////declare const bar: number[];
+////
+////const /*1*/test2: TypeEq<typeof foo, typeof bar> = false;
+
+goTo.marker("1");
+verify.quickInfoIs("const test2: false");
+
+goTo.marker("2");
+verify.quickInfoIs("const test1: false");

Original file line number	Diff line number	Diff line change
`@@ -13321,7 +13321,14 @@ namespace ts {`
`13321`	`13321`	`}`
`13322`	`13322`	`}`
`13323`	`13323`	`else if (isReadonlyArrayType(target) ? isArrayType(source) \|\| isTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) {`
`13324`		`- return isRelatedTo(getIndexTypeOfType(source, IndexKind.Number) \|\| anyType, getIndexTypeOfType(target, IndexKind.Number) \|\| anyType, reportErrors);`
	`13324`	`+ if (relation !== identityRelation) {`
	`13325`	`+ return isRelatedTo(getIndexTypeOfType(source, IndexKind.Number) \|\| anyType, getIndexTypeOfType(target, IndexKind.Number) \|\| anyType, reportErrors);`
	`13326`	`+ }`
	`13327`	`+ else {`
	`13328`	+ // By flags alone, we know that the `target` is a readonly array while the source is a normal array or tuple
	`13329`	+ // or `target` is an array and source is a tuple - in both cases the types cannot be identical, by construction
	`13330`	`+ return Ternary.False;`
	`13331`	`+ }`
`13325`	`13332`	`}`
`13326`	`13333`	// Consider a fresh empty object literal type "closed" under the subtype relationship - this way `{} <- {[idx: string]: any} <- fresh({})`
`13327`	`13334`	// and not `{} <- fresh({}) <- {[idx: string]: any}`