Keep string index from intersections in base constraint of index type

sandersn · sandersn · commit 12b80f3183cd · 2018-01-11T16:26:38.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -6468,7 +6468,7 @@ namespace ts {
         }
 
         function getConstraintOfIndexedAccess(type: IndexedAccessType) {
-            const transformed = getSimplifiedIndexedAccessType(type);
+            const transformed = getSubstitutedIndexedMappedType(type);
             if (transformed) {
                 return transformed;
             }
@@ -8383,6 +8383,11 @@ namespace ts {
                     getIntersectionType(stringIndexTypes)
                 ]);
             }
+            return getSubstitutedIndexedMappedType(type);
+        }
+
+        function getSubstitutedIndexedMappedType(type: IndexedAccessType): Type {
+            const objectType = type.objectType;
             // If the object type is a mapped type { [P in K]: E }, where K is generic, instantiate E using a mapper
             // that substitutes the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we
             // construct the type Box<T[X]>.

Original file line number	Diff line number	Diff line change
`@@ -6468,7 +6468,7 @@ namespace ts {`
`6468`	`6468`	`}`
`6469`	`6469`
`6470`	`6470`	`function getConstraintOfIndexedAccess(type: IndexedAccessType) {`
`6471`		`- const transformed = getSimplifiedIndexedAccessType(type);`
	`6471`	`+ const transformed = getSubstitutedIndexedMappedType(type);`
`6472`	`6472`	`if (transformed) {`
`6473`	`6473`	`return transformed;`
`6474`	`6474`	`}`
`@@ -8383,6 +8383,11 @@ namespace ts {`
`8383`	`8383`	`getIntersectionType(stringIndexTypes)`
`8384`	`8384`	`]);`
`8385`	`8385`	`}`
	`8386`	`+ return getSubstitutedIndexedMappedType(type);`
	`8387`	`+ }`
	`8388`	`+`
	`8389`	`+ function getSubstitutedIndexedMappedType(type: IndexedAccessType): Type {`
	`8390`	`+ const objectType = type.objectType;`
`8386`	`8391`	`// If the object type is a mapped type { [P in K]: E }, where K is generic, instantiate E using a mapper`
`8387`	`8392`	`// that substitutes the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we`
`8388`	`8393`	`// construct the type Box<T[X]>.`