From dc85623c308bc4b4c6c8a7c23d47ef80c950ab21 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Fri, 18 Aug 2017 15:13:04 -0700
Subject: [PATCH 1/8] Fix #17069 and #15371

1. `T[K]` now correctly produces `number` when
   `K extends string, T extends Record<K, number>`.

2. `T[K]` no longer allows any type to be assigned to it when
   `T extends object, K extends keyof T`.

Previously both of these cases failed in
getConstraintOfIndexedAccessType because both bases followed `K`'s base
constraint to `string` and then incorrectly produced `any` for types
(like `object`) with no string index signature. In (1), this produced an
error in checkBinaryLikeExpression`. In (2), this failed to produce an
error in `checkTypeRelatedTo`.
---
 src/compiler/checker.ts | 19 ++++++++++++-------
 src/compiler/core.ts    |  2 +-
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6df6b1f9ce1b9..ec67df6b80da5 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5911,7 +5911,14 @@ namespace ts {
                 return transformed;
             }
             const baseObjectType = getBaseConstraintOfType(type.objectType);
-            const baseIndexType = getBaseConstraintOfType(type.indexType);
+            const keepTypeParameterForMappedType = baseObjectType && getObjectFlags(baseObjectType) & ObjectFlags.Mapped &&
+                type.indexType.flags & TypeFlags.TypeParameter;
+            const baseIndexType = !keepTypeParameterForMappedType && getBaseConstraintOfType(type.indexType);
+            if (baseObjectType && baseIndexType === stringType && !getIndexInfoOfType(baseObjectType, IndexKind.String)) {
+                // getIndexedAccessType returns `any` for X[string] where X doesn't have an index signature.
+                // to avoid this, return `undefined`.
+                return undefined;
+            }
             return baseObjectType || baseIndexType ? getIndexedAccessType(baseObjectType || type.objectType, baseIndexType || type.indexType) : undefined;
         }
 
@@ -5961,8 +5968,9 @@ namespace ts {
             function computeBaseConstraint(t: Type): Type {
                 if (t.flags & TypeFlags.TypeParameter) {
                     const constraint = getConstraintFromTypeParameter(<TypeParameter>t);
-                    return (<TypeParameter>t).isThisType ? constraint :
-                        constraint ? getBaseConstraint(constraint) : undefined;
+                    return (t as TypeParameter).isThisType || !constraint ?
+                        constraint :
+                        getBaseConstraint(constraint);
                 }
                 if (t.flags & TypeFlags.UnionOrIntersection) {
                     const types = (<UnionOrIntersectionType>t).types;
@@ -5990,9 +5998,6 @@ namespace ts {
                     const baseIndexedAccess = baseObjectType && baseIndexType ? getIndexedAccessType(baseObjectType, baseIndexType) : undefined;
                     return baseIndexedAccess && baseIndexedAccess !== unknownType ? getBaseConstraint(baseIndexedAccess) : undefined;
                 }
-                if (isGenericMappedType(t)) {
-                    return emptyObjectType;
-                }
                 return t;
             }
         }
@@ -9289,7 +9294,7 @@ namespace ts {
                 }
                 else if (target.flags & TypeFlags.IndexedAccess) {
                     // A type S is related to a type T[K] if S is related to A[K], where K is string-like and
-                    // A is the apparent type of S.
+                    // A is the apparent type of T.
                     const constraint = getConstraintOfType(<IndexedAccessType>target);
                     if (constraint) {
                         if (result = isRelatedTo(source, constraint, reportErrors)) {
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 8cab1b4115502..422df2ead0504 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -718,7 +718,7 @@ namespace ts {
     export function sum<T extends Record<K, number>, K extends string>(array: T[], prop: K): number {
         let result = 0;
         for (const v of array) {
-            // Note: we need the following type assertion because of GH #17069
+            // TODO: Remove the following type assertion once the fix for #17069 is merged
             result += v[prop] as number;
         }
         return result;

From ecae295c5a70ebe1be2c13119a818a8bfabfbc1b Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Fri, 18 Aug 2017 15:16:24 -0700
Subject: [PATCH 2/8] Test getConstraintOfIndexedAccess fixes and update
 baselines

---
 ...ionOperatorWithConstrainedTypeParameter.js | 27 ++++++++
 ...eratorWithConstrainedTypeParameter.symbols | 54 +++++++++++++++
 ...OperatorWithConstrainedTypeParameter.types | 64 ++++++++++++++++++
 ...tiveConstraintOfIndexAccessType.errors.txt | 67 +++++++++++++++++++
 ...nonPrimitiveConstraintOfIndexAccessType.js | 67 +++++++++++++++++++
 ...ionOperatorWithConstrainedTypeParameter.ts | 11 +++
 ...nonPrimitiveConstraintOfIndexAccessType.ts | 32 +++++++++
 7 files changed, 322 insertions(+)
 create mode 100644 tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.js
 create mode 100644 tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.symbols
 create mode 100644 tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.types
 create mode 100644 tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.errors.txt
 create mode 100644 tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.js
 create mode 100644 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithConstrainedTypeParameter.ts
 create mode 100644 tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts

diff --git a/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.js b/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.js
new file mode 100644
index 0000000000000..1366e242182e4
--- /dev/null
+++ b/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.js
@@ -0,0 +1,27 @@
+//// [additionOperatorWithConstrainedTypeParameter.ts]
+// test for #17069
+function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k: K) {
+    n = n + v[k];
+    n += v[k]; // += should work the same way
+}
+function realSum<T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) {
+    for (const v of vs) {
+        n = n + v[k];
+        n += v[k];
+    }
+}
+
+
+//// [additionOperatorWithConstrainedTypeParameter.js]
+// test for #17069
+function sum(n, v, k) {
+    n = n + v[k];
+    n += v[k]; // += should work the same way
+}
+function realSum(n, vs, k) {
+    for (var _i = 0, vs_1 = vs; _i < vs_1.length; _i++) {
+        var v = vs_1[_i];
+        n = n + v[k];
+        n += v[k];
+    }
+}
diff --git a/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.symbols b/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.symbols
new file mode 100644
index 0000000000000..e7055c1e38f8d
--- /dev/null
+++ b/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.symbols
@@ -0,0 +1,54 @@
+=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithConstrainedTypeParameter.ts ===
+// test for #17069
+function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k: K) {
+>sum : Symbol(sum, Decl(additionOperatorWithConstrainedTypeParameter.ts, 0, 0))
+>T : Symbol(T, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 13))
+>Record : Symbol(Record, Decl(lib.d.ts, --, --))
+>K : Symbol(K, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 41))
+>K : Symbol(K, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 41))
+>n : Symbol(n, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 60))
+>v : Symbol(v, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 70))
+>T : Symbol(T, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 13))
+>k : Symbol(k, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 76))
+>K : Symbol(K, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 41))
+
+    n = n + v[k];
+>n : Symbol(n, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 60))
+>n : Symbol(n, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 60))
+>v : Symbol(v, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 70))
+>k : Symbol(k, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 76))
+
+    n += v[k]; // += should work the same way
+>n : Symbol(n, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 60))
+>v : Symbol(v, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 70))
+>k : Symbol(k, Decl(additionOperatorWithConstrainedTypeParameter.ts, 1, 76))
+}
+function realSum<T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) {
+>realSum : Symbol(realSum, Decl(additionOperatorWithConstrainedTypeParameter.ts, 4, 1))
+>T : Symbol(T, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 17))
+>Record : Symbol(Record, Decl(lib.d.ts, --, --))
+>K : Symbol(K, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 45))
+>K : Symbol(K, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 45))
+>n : Symbol(n, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 64))
+>vs : Symbol(vs, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 74))
+>T : Symbol(T, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 17))
+>k : Symbol(k, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 83))
+>K : Symbol(K, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 45))
+
+    for (const v of vs) {
+>v : Symbol(v, Decl(additionOperatorWithConstrainedTypeParameter.ts, 6, 14))
+>vs : Symbol(vs, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 74))
+
+        n = n + v[k];
+>n : Symbol(n, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 64))
+>n : Symbol(n, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 64))
+>v : Symbol(v, Decl(additionOperatorWithConstrainedTypeParameter.ts, 6, 14))
+>k : Symbol(k, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 83))
+
+        n += v[k];
+>n : Symbol(n, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 64))
+>v : Symbol(v, Decl(additionOperatorWithConstrainedTypeParameter.ts, 6, 14))
+>k : Symbol(k, Decl(additionOperatorWithConstrainedTypeParameter.ts, 5, 83))
+    }
+}
+
diff --git a/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.types b/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.types
new file mode 100644
index 0000000000000..d52c77a94fd69
--- /dev/null
+++ b/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.types
@@ -0,0 +1,64 @@
+=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithConstrainedTypeParameter.ts ===
+// test for #17069
+function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k: K) {
+>sum : <T extends Record<K, number>, K extends string>(n: number, v: T, k: K) => void
+>T : T
+>Record : Record<K, T>
+>K : K
+>K : K
+>n : number
+>v : T
+>T : T
+>k : K
+>K : K
+
+    n = n + v[k];
+>n = n + v[k] : number
+>n : number
+>n + v[k] : number
+>n : number
+>v[k] : T[K]
+>v : T
+>k : K
+
+    n += v[k]; // += should work the same way
+>n += v[k] : number
+>n : number
+>v[k] : T[K]
+>v : T
+>k : K
+}
+function realSum<T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) {
+>realSum : <T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) => void
+>T : T
+>Record : Record<K, T>
+>K : K
+>K : K
+>n : number
+>vs : T[]
+>T : T
+>k : K
+>K : K
+
+    for (const v of vs) {
+>v : T
+>vs : T[]
+
+        n = n + v[k];
+>n = n + v[k] : number
+>n : number
+>n + v[k] : number
+>n : number
+>v[k] : T[K]
+>v : T
+>k : K
+
+        n += v[k];
+>n += v[k] : number
+>n : number
+>v[k] : T[K]
+>v : T
+>k : K
+    }
+}
+
diff --git a/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.errors.txt b/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.errors.txt
new file mode 100644
index 0000000000000..56781157131a4
--- /dev/null
+++ b/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.errors.txt
@@ -0,0 +1,67 @@
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(3,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(6,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(9,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(12,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(15,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(18,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(21,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(24,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(27,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts(30,5): error TS2322: Type 'string' is not assignable to type 'T[P]'.
+  Type 'string' is not assignable to type 'number'.
+
+
+==== tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts (10 errors) ====
+    // test for #15371
+    function f<T extends object, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+    }
+    function g<T extends null, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+    }
+    function h<T extends undefined, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+    }
+    function i<T extends void, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+    }
+    function j<T extends never, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+    }
+    function k<T extends number, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+    }
+    function o<T extends string, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+    }
+    function l<T extends {}, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+    }
+    function m<T extends { a: number }, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+    }
+    function n<T extends { [s: string]: number }, P extends keyof T>(s: string, tp: T[P]): void {
+        tp = s;
+        ~~
+!!! error TS2322: Type 'string' is not assignable to type 'T[P]'.
+!!! error TS2322:   Type 'string' is not assignable to type 'number'.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.js b/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.js
new file mode 100644
index 0000000000000..7a24345a94b11
--- /dev/null
+++ b/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.js
@@ -0,0 +1,67 @@
+//// [nonPrimitiveConstraintOfIndexAccessType.ts]
+// test for #15371
+function f<T extends object, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function g<T extends null, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function h<T extends undefined, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function i<T extends void, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function j<T extends never, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function k<T extends number, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function o<T extends string, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function l<T extends {}, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function m<T extends { a: number }, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function n<T extends { [s: string]: number }, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+
+
+//// [nonPrimitiveConstraintOfIndexAccessType.js]
+"use strict";
+// test for #15371
+function f(s, tp) {
+    tp = s;
+}
+function g(s, tp) {
+    tp = s;
+}
+function h(s, tp) {
+    tp = s;
+}
+function i(s, tp) {
+    tp = s;
+}
+function j(s, tp) {
+    tp = s;
+}
+function k(s, tp) {
+    tp = s;
+}
+function o(s, tp) {
+    tp = s;
+}
+function l(s, tp) {
+    tp = s;
+}
+function m(s, tp) {
+    tp = s;
+}
+function n(s, tp) {
+    tp = s;
+}
diff --git a/tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithConstrainedTypeParameter.ts b/tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithConstrainedTypeParameter.ts
new file mode 100644
index 0000000000000..2303bb33944ad
--- /dev/null
+++ b/tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithConstrainedTypeParameter.ts
@@ -0,0 +1,11 @@
+// test for #17069
+function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k: K) {
+    n = n + v[k];
+    n += v[k]; // += should work the same way
+}
+function realSum<T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) {
+    for (const v of vs) {
+        n = n + v[k];
+        n += v[k];
+    }
+}
diff --git a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts
new file mode 100644
index 0000000000000..1e852f12f928e
--- /dev/null
+++ b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts
@@ -0,0 +1,32 @@
+// @strict: true
+// test for #15371
+function f<T extends object, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function g<T extends null, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function h<T extends undefined, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function i<T extends void, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function j<T extends never, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function k<T extends number, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function o<T extends string, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function l<T extends {}, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function m<T extends { a: number }, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}
+function n<T extends { [s: string]: number }, P extends keyof T>(s: string, tp: T[P]): void {
+    tp = s;
+}

From 04339d2df7c3483bcbc44a92a8e4840274aaef02 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 28 Aug 2017 09:05:56 -0700
Subject: [PATCH 3/8] Disallow T[K] = T[keyof T] where K extends keyof T

`K = keyof T` was already correctly disallowed.
---
 src/compiler/checker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 8e34b24cf1b94..27b0752f53f51 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5914,7 +5914,7 @@ namespace ts {
             const keepTypeParameterForMappedType = baseObjectType && getObjectFlags(baseObjectType) & ObjectFlags.Mapped &&
                 type.indexType.flags & TypeFlags.TypeParameter;
             const baseIndexType = !keepTypeParameterForMappedType && getBaseConstraintOfType(type.indexType);
-            if (baseObjectType && baseIndexType === stringType && !getIndexInfoOfType(baseObjectType, IndexKind.String)) {
+            if (baseIndexType === stringType && (!baseObjectType || !getIndexInfoOfType(baseObjectType, IndexKind.String))) {
                 // getIndexedAccessType returns `any` for X[string] where X doesn't have an index signature.
                 // to avoid this, return `undefined`.
                 return undefined;

From 20e579847a086119e309906e6811508cf08d7287 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 28 Aug 2017 09:12:14 -0700
Subject: [PATCH 4/8] Test:T[keyof T] =/=> T[K] where K extends keyof T

---
 .../indexedAccessRelation2.errors.txt         | 18 ++++++++++++++++++
 .../reference/indexedAccessRelation2.js       | 19 +++++++++++++++++++
 .../cases/compiler/indexedAccessRelation2.ts  |  8 ++++++++
 3 files changed, 45 insertions(+)
 create mode 100644 tests/baselines/reference/indexedAccessRelation2.errors.txt
 create mode 100644 tests/baselines/reference/indexedAccessRelation2.js
 create mode 100644 tests/cases/compiler/indexedAccessRelation2.ts

diff --git a/tests/baselines/reference/indexedAccessRelation2.errors.txt b/tests/baselines/reference/indexedAccessRelation2.errors.txt
new file mode 100644
index 0000000000000..b208e92250f22
--- /dev/null
+++ b/tests/baselines/reference/indexedAccessRelation2.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/compiler/indexedAccessRelation2.ts(4,9): error TS2322: Type 'keyof T' is not assignable to type 'K'.
+tests/cases/compiler/indexedAccessRelation2.ts(5,9): error TS2322: Type 'T[keyof T]' is not assignable to type 'T[K]'.
+
+
+==== tests/cases/compiler/indexedAccessRelation2.ts (2 errors) ====
+    // Repro from #17166
+    function f<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
+        for (let key in obj) {
+            k = key // error, keyof T =/=> K
+            ~
+!!! error TS2322: Type 'keyof T' is not assignable to type 'K'.
+            value = obj[key]; // error, T[keyof T] =/=> T[K]
+            ~~~~~
+!!! error TS2322: Type 'T[keyof T]' is not assignable to type 'T[K]'.
+        }
+    }
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/indexedAccessRelation2.js b/tests/baselines/reference/indexedAccessRelation2.js
new file mode 100644
index 0000000000000..39b093ef3f779
--- /dev/null
+++ b/tests/baselines/reference/indexedAccessRelation2.js
@@ -0,0 +1,19 @@
+//// [indexedAccessRelation2.ts]
+// Repro from #17166
+function f<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
+    for (let key in obj) {
+        k = key // error, keyof T =/=> K
+        value = obj[key]; // error, T[keyof T] =/=> T[K]
+    }
+}
+
+
+
+//// [indexedAccessRelation2.js]
+// Repro from #17166
+function f(obj, k, value) {
+    for (var key in obj) {
+        k = key; // error, keyof T =/=> K
+        value = obj[key]; // error, T[keyof T] =/=> T[K]
+    }
+}
diff --git a/tests/cases/compiler/indexedAccessRelation2.ts b/tests/cases/compiler/indexedAccessRelation2.ts
new file mode 100644
index 0000000000000..736651099dc37
--- /dev/null
+++ b/tests/cases/compiler/indexedAccessRelation2.ts
@@ -0,0 +1,8 @@
+// Repro from #17166
+function f<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
+    for (let key in obj) {
+        k = key // error, keyof T =/=> K
+        value = obj[key]; // error, T[keyof T] =/=> T[K]
+    }
+}
+

From 2f646daf0ab38c10e2149507f2497204f2eb09f9 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 28 Aug 2017 10:53:11 -0700
Subject: [PATCH 5/8] Move lone test case into central test file

---
 .../indexedAccessRelation2.errors.txt         | 18 -----------------
 .../reference/indexedAccessRelation2.js       | 19 ------------------
 .../keyofAndIndexedAccessErrors.errors.txt    | 20 +++++++++++++++++--
 .../reference/keyofAndIndexedAccessErrors.js  | 19 +++++++++++++++++-
 .../cases/compiler/indexedAccessRelation2.ts  |  8 --------
 .../keyof/keyofAndIndexedAccessErrors.ts      | 11 +++++++++-
 6 files changed, 46 insertions(+), 49 deletions(-)
 delete mode 100644 tests/baselines/reference/indexedAccessRelation2.errors.txt
 delete mode 100644 tests/baselines/reference/indexedAccessRelation2.js
 delete mode 100644 tests/cases/compiler/indexedAccessRelation2.ts

diff --git a/tests/baselines/reference/indexedAccessRelation2.errors.txt b/tests/baselines/reference/indexedAccessRelation2.errors.txt
deleted file mode 100644
index b208e92250f22..0000000000000
--- a/tests/baselines/reference/indexedAccessRelation2.errors.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-tests/cases/compiler/indexedAccessRelation2.ts(4,9): error TS2322: Type 'keyof T' is not assignable to type 'K'.
-tests/cases/compiler/indexedAccessRelation2.ts(5,9): error TS2322: Type 'T[keyof T]' is not assignable to type 'T[K]'.
-
-
-==== tests/cases/compiler/indexedAccessRelation2.ts (2 errors) ====
-    // Repro from #17166
-    function f<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
-        for (let key in obj) {
-            k = key // error, keyof T =/=> K
-            ~
-!!! error TS2322: Type 'keyof T' is not assignable to type 'K'.
-            value = obj[key]; // error, T[keyof T] =/=> T[K]
-            ~~~~~
-!!! error TS2322: Type 'T[keyof T]' is not assignable to type 'T[K]'.
-        }
-    }
-    
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/indexedAccessRelation2.js b/tests/baselines/reference/indexedAccessRelation2.js
deleted file mode 100644
index 39b093ef3f779..0000000000000
--- a/tests/baselines/reference/indexedAccessRelation2.js
+++ /dev/null
@@ -1,19 +0,0 @@
-//// [indexedAccessRelation2.ts]
-// Repro from #17166
-function f<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
-    for (let key in obj) {
-        k = key // error, keyof T =/=> K
-        value = obj[key]; // error, T[keyof T] =/=> T[K]
-    }
-}
-
-
-
-//// [indexedAccessRelation2.js]
-// Repro from #17166
-function f(obj, k, value) {
-    for (var key in obj) {
-        k = key; // error, keyof T =/=> K
-        value = obj[key]; // error, T[keyof T] =/=> T[K]
-    }
-}
diff --git a/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt b/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt
index 0634c3419e014..2981cb0366d8b 100644
--- a/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt
+++ b/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt
@@ -27,9 +27,11 @@ tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(76,5): error
   Type 'T' is not assignable to type 'T & U'.
     Type 'T' is not assignable to type 'U'.
 tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(77,5): error TS2322: Type 'keyof (T & U)' is not assignable to type 'keyof (T | U)'.
+tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(84,9): error TS2322: Type 'keyof T' is not assignable to type 'K'.
+tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(85,9): error TS2322: Type 'T[keyof T]' is not assignable to type 'T[K]'.
 
 
-==== tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts (25 errors) ====
+==== tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts (27 errors) ====
     class Shape {
         name: string;
         width: number;
@@ -162,4 +164,18 @@ tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(77,5): error
         ~~
 !!! error TS2322: Type 'keyof (T & U)' is not assignable to type 'keyof (T | U)'.
         k2 = k1;
-    }
\ No newline at end of file
+    }
+    
+    // Repro from #17166
+    function f3<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
+        for (let key in obj) {
+            k = key // error, keyof T =/=> K
+            ~
+!!! error TS2322: Type 'keyof T' is not assignable to type 'K'.
+            value = obj[key]; // error, T[keyof T] =/=> T[K]
+            ~~~~~
+!!! error TS2322: Type 'T[keyof T]' is not assignable to type 'T[K]'.
+        }
+    }
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/keyofAndIndexedAccessErrors.js b/tests/baselines/reference/keyofAndIndexedAccessErrors.js
index 838a3a6a86b80..2a1042cf4eeb1 100644
--- a/tests/baselines/reference/keyofAndIndexedAccessErrors.js
+++ b/tests/baselines/reference/keyofAndIndexedAccessErrors.js
@@ -77,7 +77,17 @@ function f20<T, U>(k1: keyof (T | U), k2: keyof (T & U), o1: T | U, o2: T & U) {
     o2 = o1;  // Error
     k1 = k2;  // Error
     k2 = k1;
-}
+}
+
+// Repro from #17166
+function f3<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
+    for (let key in obj) {
+        k = key // error, keyof T =/=> K
+        value = obj[key]; // error, T[keyof T] =/=> T[K]
+    }
+}
+
+
 
 //// [keyofAndIndexedAccessErrors.js]
 var Shape = /** @class */ (function () {
@@ -109,3 +119,10 @@ function f20(k1, k2, o1, o2) {
     k1 = k2; // Error
     k2 = k1;
 }
+// Repro from #17166
+function f3(obj, k, value) {
+    for (var key in obj) {
+        k = key; // error, keyof T =/=> K
+        value = obj[key]; // error, T[keyof T] =/=> T[K]
+    }
+}
diff --git a/tests/cases/compiler/indexedAccessRelation2.ts b/tests/cases/compiler/indexedAccessRelation2.ts
deleted file mode 100644
index 736651099dc37..0000000000000
--- a/tests/cases/compiler/indexedAccessRelation2.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-// Repro from #17166
-function f<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
-    for (let key in obj) {
-        k = key // error, keyof T =/=> K
-        value = obj[key]; // error, T[keyof T] =/=> T[K]
-    }
-}
-
diff --git a/tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts b/tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts
index cbbc9a5220086..ffc5076831ae0 100644
--- a/tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts
+++ b/tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts
@@ -76,4 +76,13 @@ function f20<T, U>(k1: keyof (T | U), k2: keyof (T & U), o1: T | U, o2: T & U) {
     o2 = o1;  // Error
     k1 = k2;  // Error
     k2 = k1;
-}
\ No newline at end of file
+}
+
+// Repro from #17166
+function f3<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
+    for (let key in obj) {
+        k = key // error, keyof T =/=> K
+        value = obj[key]; // error, T[keyof T] =/=> T[K]
+    }
+}
+

From 71b7429cb26237e97748c839fa7ded0f422b47d9 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com>
Date: Mon, 4 Dec 2017 15:40:09 -0800
Subject: [PATCH 6/8] Update baselines

After merging with master, even erroneous tests generate types and
symbols baselines
---
 .../keyofAndIndexedAccessErrors.symbols       |  31 ++++
 .../keyofAndIndexedAccessErrors.types         |  34 ++++
 ...imitiveConstraintOfIndexAccessType.symbols | 145 ++++++++++++++++
 ...PrimitiveConstraintOfIndexAccessType.types | 156 ++++++++++++++++++
 4 files changed, 366 insertions(+)
 create mode 100644 tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.symbols
 create mode 100644 tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.types

diff --git a/tests/baselines/reference/keyofAndIndexedAccessErrors.symbols b/tests/baselines/reference/keyofAndIndexedAccessErrors.symbols
index 36fb8d2989b9c..0e97ef793fb30 100644
--- a/tests/baselines/reference/keyofAndIndexedAccessErrors.symbols
+++ b/tests/baselines/reference/keyofAndIndexedAccessErrors.symbols
@@ -268,3 +268,34 @@ function f20<T, U>(k1: keyof (T | U), k2: keyof (T & U), o1: T | U, o2: T & U) {
 >k2 : Symbol(k2, Decl(keyofAndIndexedAccessErrors.ts, 69, 37))
 >k1 : Symbol(k1, Decl(keyofAndIndexedAccessErrors.ts, 69, 19))
 }
+
+// Repro from #17166
+function f3<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
+>f3 : Symbol(f3, Decl(keyofAndIndexedAccessErrors.ts, 78, 1))
+>T : Symbol(T, Decl(keyofAndIndexedAccessErrors.ts, 81, 12))
+>K : Symbol(K, Decl(keyofAndIndexedAccessErrors.ts, 81, 14))
+>T : Symbol(T, Decl(keyofAndIndexedAccessErrors.ts, 81, 12))
+>obj : Symbol(obj, Decl(keyofAndIndexedAccessErrors.ts, 81, 34))
+>T : Symbol(T, Decl(keyofAndIndexedAccessErrors.ts, 81, 12))
+>k : Symbol(k, Decl(keyofAndIndexedAccessErrors.ts, 81, 41))
+>K : Symbol(K, Decl(keyofAndIndexedAccessErrors.ts, 81, 14))
+>value : Symbol(value, Decl(keyofAndIndexedAccessErrors.ts, 81, 47))
+>T : Symbol(T, Decl(keyofAndIndexedAccessErrors.ts, 81, 12))
+>K : Symbol(K, Decl(keyofAndIndexedAccessErrors.ts, 81, 14))
+
+    for (let key in obj) {
+>key : Symbol(key, Decl(keyofAndIndexedAccessErrors.ts, 82, 12))
+>obj : Symbol(obj, Decl(keyofAndIndexedAccessErrors.ts, 81, 34))
+
+        k = key // error, keyof T =/=> K
+>k : Symbol(k, Decl(keyofAndIndexedAccessErrors.ts, 81, 41))
+>key : Symbol(key, Decl(keyofAndIndexedAccessErrors.ts, 82, 12))
+
+        value = obj[key]; // error, T[keyof T] =/=> T[K]
+>value : Symbol(value, Decl(keyofAndIndexedAccessErrors.ts, 81, 47))
+>obj : Symbol(obj, Decl(keyofAndIndexedAccessErrors.ts, 81, 34))
+>key : Symbol(key, Decl(keyofAndIndexedAccessErrors.ts, 82, 12))
+    }
+}
+
+
diff --git a/tests/baselines/reference/keyofAndIndexedAccessErrors.types b/tests/baselines/reference/keyofAndIndexedAccessErrors.types
index 4d2e25641d39d..f5cc7c093d92e 100644
--- a/tests/baselines/reference/keyofAndIndexedAccessErrors.types
+++ b/tests/baselines/reference/keyofAndIndexedAccessErrors.types
@@ -299,3 +299,37 @@ function f20<T, U>(k1: keyof (T | U), k2: keyof (T & U), o1: T | U, o2: T & U) {
 >k2 : keyof (T & U)
 >k1 : keyof (T | U)
 }
+
+// Repro from #17166
+function f3<T, K extends keyof T>(obj: T, k: K, value: T[K]): void {
+>f3 : <T, K extends keyof T>(obj: T, k: K, value: T[K]) => void
+>T : T
+>K : K
+>T : T
+>obj : T
+>T : T
+>k : K
+>K : K
+>value : T[K]
+>T : T
+>K : K
+
+    for (let key in obj) {
+>key : keyof T
+>obj : T
+
+        k = key // error, keyof T =/=> K
+>k = key : keyof T
+>k : K
+>key : keyof T
+
+        value = obj[key]; // error, T[keyof T] =/=> T[K]
+>value = obj[key] : T[keyof T]
+>value : T[K]
+>obj[key] : T[keyof T]
+>obj : T
+>key : keyof T
+    }
+}
+
+
diff --git a/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.symbols b/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.symbols
new file mode 100644
index 0000000000000..3ada1e3f3d1c8
--- /dev/null
+++ b/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.symbols
@@ -0,0 +1,145 @@
+=== tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts ===
+// test for #15371
+function f<T extends object, P extends keyof T>(s: string, tp: T[P]): void {
+>f : Symbol(f, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 0, 0))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 1, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 1, 28))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 1, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 1, 48))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 1, 58))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 1, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 1, 28))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 1, 58))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 1, 48))
+}
+function g<T extends null, P extends keyof T>(s: string, tp: T[P]): void {
+>g : Symbol(g, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 3, 1))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 4, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 4, 26))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 4, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 4, 46))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 4, 56))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 4, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 4, 26))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 4, 56))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 4, 46))
+}
+function h<T extends undefined, P extends keyof T>(s: string, tp: T[P]): void {
+>h : Symbol(h, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 6, 1))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 7, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 7, 31))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 7, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 7, 51))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 7, 61))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 7, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 7, 31))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 7, 61))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 7, 51))
+}
+function i<T extends void, P extends keyof T>(s: string, tp: T[P]): void {
+>i : Symbol(i, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 9, 1))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 10, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 10, 26))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 10, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 10, 46))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 10, 56))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 10, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 10, 26))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 10, 56))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 10, 46))
+}
+function j<T extends never, P extends keyof T>(s: string, tp: T[P]): void {
+>j : Symbol(j, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 12, 1))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 13, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 13, 27))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 13, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 13, 47))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 13, 57))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 13, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 13, 27))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 13, 57))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 13, 47))
+}
+function k<T extends number, P extends keyof T>(s: string, tp: T[P]): void {
+>k : Symbol(k, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 15, 1))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 16, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 16, 28))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 16, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 16, 48))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 16, 58))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 16, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 16, 28))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 16, 58))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 16, 48))
+}
+function o<T extends string, P extends keyof T>(s: string, tp: T[P]): void {
+>o : Symbol(o, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 18, 1))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 19, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 19, 28))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 19, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 19, 48))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 19, 58))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 19, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 19, 28))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 19, 58))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 19, 48))
+}
+function l<T extends {}, P extends keyof T>(s: string, tp: T[P]): void {
+>l : Symbol(l, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 21, 1))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 22, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 22, 24))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 22, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 22, 44))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 22, 54))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 22, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 22, 24))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 22, 54))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 22, 44))
+}
+function m<T extends { a: number }, P extends keyof T>(s: string, tp: T[P]): void {
+>m : Symbol(m, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 24, 1))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 11))
+>a : Symbol(a, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 22))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 35))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 55))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 65))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 35))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 65))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 25, 55))
+}
+function n<T extends { [s: string]: number }, P extends keyof T>(s: string, tp: T[P]): void {
+>n : Symbol(n, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 27, 1))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 24))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 45))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 11))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 65))
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 75))
+>T : Symbol(T, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 11))
+>P : Symbol(P, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 45))
+
+    tp = s;
+>tp : Symbol(tp, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 75))
+>s : Symbol(s, Decl(nonPrimitiveConstraintOfIndexAccessType.ts, 28, 65))
+}
+
diff --git a/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.types b/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.types
new file mode 100644
index 0000000000000..d5e8560d7cf46
--- /dev/null
+++ b/tests/baselines/reference/nonPrimitiveConstraintOfIndexAccessType.types
@@ -0,0 +1,156 @@
+=== tests/cases/conformance/types/nonPrimitive/nonPrimitiveConstraintOfIndexAccessType.ts ===
+// test for #15371
+function f<T extends object, P extends keyof T>(s: string, tp: T[P]): void {
+>f : <T extends object, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+function g<T extends null, P extends keyof T>(s: string, tp: T[P]): void {
+>g : <T extends null, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>null : null
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+function h<T extends undefined, P extends keyof T>(s: string, tp: T[P]): void {
+>h : <T extends undefined, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+function i<T extends void, P extends keyof T>(s: string, tp: T[P]): void {
+>i : <T extends void, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+function j<T extends never, P extends keyof T>(s: string, tp: T[P]): void {
+>j : <T extends never, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+function k<T extends number, P extends keyof T>(s: string, tp: T[P]): void {
+>k : <T extends number, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+function o<T extends string, P extends keyof T>(s: string, tp: T[P]): void {
+>o : <T extends string, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+function l<T extends {}, P extends keyof T>(s: string, tp: T[P]): void {
+>l : <T extends {}, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+function m<T extends { a: number }, P extends keyof T>(s: string, tp: T[P]): void {
+>m : <T extends { a: number; }, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>a : number
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+function n<T extends { [s: string]: number }, P extends keyof T>(s: string, tp: T[P]): void {
+>n : <T extends { [s: string]: number; }, P extends keyof T>(s: string, tp: T[P]) => void
+>T : T
+>s : string
+>P : P
+>T : T
+>s : string
+>tp : T[P]
+>T : T
+>P : P
+
+    tp = s;
+>tp = s : string
+>tp : T[P]
+>s : string
+}
+

From 0b23811a5635e41c8d4cf3bd156930617019760c Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com>
Date: Wed, 10 Jan 2018 14:00:52 -0800
Subject: [PATCH 7/8] Handle indexed mapped types in transformIndexedAccessType

Also rename transformIndexedAccessType to simplifyIndexedAccessType
---
 src/compiler/checker.ts | 33 ++++++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index d530ef8e33467..a5e21ff653538 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6351,7 +6351,7 @@ namespace ts {
             return getObjectFlags(type) & ObjectFlags.Mapped && !!(<MappedType>type).declaration.questionToken;
         }
 
-        function isGenericMappedType(type: Type) {
+        function isGenericMappedType(type: Type): type is MappedType {
             return getObjectFlags(type) & ObjectFlags.Mapped && isGenericIndexType(getConstraintTypeFromMappedType(<MappedType>type));
         }
 
@@ -6463,14 +6463,12 @@ namespace ts {
         }
 
         function getConstraintOfIndexedAccess(type: IndexedAccessType) {
-            const transformed = getTransformedIndexedAccessType(type);
+            const transformed = simplifyIndexedAccessType(type);
             if (transformed) {
                 return transformed;
             }
             const baseObjectType = getBaseConstraintOfType(type.objectType);
-            const keepTypeParameterForMappedType = baseObjectType && getObjectFlags(baseObjectType) & ObjectFlags.Mapped &&
-                type.indexType.flags & TypeFlags.TypeParameter;
-            const baseIndexType = !keepTypeParameterForMappedType && getBaseConstraintOfType(type.indexType);
+            const baseIndexType = getBaseConstraintOfType(type.indexType);
             if (baseIndexType === stringType && !getIndexInfoOfType(baseObjectType || type.objectType, IndexKind.String)) {
                 // getIndexedAccessType returns `any` for X[string] where X doesn't have an index signature.
                 // to avoid this, return `undefined`.
@@ -6546,7 +6544,7 @@ namespace ts {
                     return stringType;
                 }
                 if (t.flags & TypeFlags.IndexedAccess) {
-                    const transformed = getTransformedIndexedAccessType(<IndexedAccessType>t);
+                    const transformed = simplifyIndexedAccessType(<IndexedAccessType>t);
                     if (transformed) {
                         return getBaseConstraint(transformed);
                     }
@@ -6555,6 +6553,9 @@ namespace ts {
                     const baseIndexedAccess = baseObjectType && baseIndexType ? getIndexedAccessType(baseObjectType, baseIndexType) : undefined;
                     return baseIndexedAccess && baseIndexedAccess !== unknownType ? getBaseConstraint(baseIndexedAccess) : undefined;
                 }
+                if (isGenericMappedType(t)) {
+                    return emptyObjectType;
+                }
                 return t;
             }
         }
@@ -8355,7 +8356,7 @@ namespace ts {
 
         // Transform an indexed access to a simpler form, if possible. Return the simpler form, or return
         // undefined if no transformation is possible.
-        function getTransformedIndexedAccessType(type: IndexedAccessType): Type {
+        function simplifyIndexedAccessType(type: IndexedAccessType): Type {
             const objectType = type.objectType;
             // Given an indexed access type T[K], if T is an intersection containing one or more generic types and one or
             // more object types with only a string index signature, e.g. '(U & V & { [x: string]: D })[K]', return a
@@ -8381,14 +8382,24 @@ namespace ts {
             // 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]>.
             if (isGenericMappedType(objectType)) {
-                const mapper = createTypeMapper([getTypeParameterFromMappedType(<MappedType>objectType)], [type.indexType]);
-                const objectTypeMapper = (<MappedType>objectType).mapper;
-                const templateMapper = objectTypeMapper ? combineTypeMappers(objectTypeMapper, mapper) : mapper;
-                return instantiateType(getTemplateTypeFromMappedType(<MappedType>objectType), templateMapper);
+                return substituteIndexedMappedType(objectType, type);
+            }
+            if (objectType.flags & TypeFlags.TypeParameter) {
+                const constraint = getConstraintFromTypeParameter(objectType as TypeParameter);
+                if (constraint && isGenericMappedType(constraint)) {
+                    return substituteIndexedMappedType(constraint, type);
+                }
             }
             return undefined;
         }
 
+        function substituteIndexedMappedType(objectType: MappedType, type: IndexedAccessType) {
+            const mapper = createTypeMapper([getTypeParameterFromMappedType(<MappedType>objectType)], [type.indexType]);
+            const objectTypeMapper = (<MappedType>objectType).mapper;
+            const templateMapper = objectTypeMapper ? combineTypeMappers(objectTypeMapper, mapper) : mapper;
+            return instantiateType(getTemplateTypeFromMappedType(<MappedType>objectType), templateMapper);
+        }
+
         function getIndexedAccessType(objectType: Type, indexType: Type, accessNode?: ElementAccessExpression | IndexedAccessTypeNode): Type {
             // If the index type is generic, or if the object type is generic and doesn't originate in an expression,
             // we are performing a higher-order index access where we cannot meaningfully access the properties of the

From 8f45373e442034fb94aef20f9f7b65dc8d38ebb9 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com>
Date: Wed, 10 Jan 2018 14:43:55 -0800
Subject: [PATCH 8/8] Rename
 simplifyIndexedAccessType->getSimplifiedIndexedAccessType

---
 src/compiler/checker.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index a5e21ff653538..8504074080ae5 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6463,7 +6463,7 @@ namespace ts {
         }
 
         function getConstraintOfIndexedAccess(type: IndexedAccessType) {
-            const transformed = simplifyIndexedAccessType(type);
+            const transformed = getSimplifiedIndexedAccessType(type);
             if (transformed) {
                 return transformed;
             }
@@ -6544,7 +6544,7 @@ namespace ts {
                     return stringType;
                 }
                 if (t.flags & TypeFlags.IndexedAccess) {
-                    const transformed = simplifyIndexedAccessType(<IndexedAccessType>t);
+                    const transformed = getSimplifiedIndexedAccessType(<IndexedAccessType>t);
                     if (transformed) {
                         return getBaseConstraint(transformed);
                     }
@@ -8356,7 +8356,7 @@ namespace ts {
 
         // Transform an indexed access to a simpler form, if possible. Return the simpler form, or return
         // undefined if no transformation is possible.
-        function simplifyIndexedAccessType(type: IndexedAccessType): Type {
+        function getSimplifiedIndexedAccessType(type: IndexedAccessType): Type {
             const objectType = type.objectType;
             // Given an indexed access type T[K], if T is an intersection containing one or more generic types and one or
             // more object types with only a string index signature, e.g. '(U & V & { [x: string]: D })[K]', return a