Merge pull request #31000 from Microsoft/ignoreStringIndexSignaturesOnly

ahejlsberg · web-flow · commit 95413f0a2494 · 2019-04-25T17:01:46.000-07:00
Ignore string (but keep numeric) index signatures from constraints
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -9942,13 +9942,13 @@ namespace ts {
             return type.flags & TypeFlags.Union ? getIntersectionType(map((<IntersectionType>type).types, t => getIndexType(t, stringsOnly, noIndexSignatures))) :
                 type.flags & TypeFlags.Intersection ? getUnionType(map((<IntersectionType>type).types, t => getIndexType(t, stringsOnly, noIndexSignatures))) :
                 maybeTypeOfKind(type, TypeFlags.InstantiableNonPrimitive) ? getIndexTypeForGenericType(<InstantiableType | UnionOrIntersectionType>type, stringsOnly) :
-                getObjectFlags(type) & ObjectFlags.Mapped ? filterType(getConstraintTypeFromMappedType(<MappedType>type), t => !(noIndexSignatures && t.flags & (TypeFlags.Any | TypeFlags.String | TypeFlags.Number))) :
+                getObjectFlags(type) & ObjectFlags.Mapped ? filterType(getConstraintTypeFromMappedType(<MappedType>type), t => !(noIndexSignatures && t.flags & (TypeFlags.Any | TypeFlags.String))) :
                 type === wildcardType ? wildcardType :
                 type.flags & TypeFlags.Unknown ? neverType :
                 type.flags & (TypeFlags.Any | TypeFlags.Never) ? keyofConstraintType :
                 stringsOnly ? !noIndexSignatures && getIndexInfoOfType(type, IndexKind.String) ? stringType : getLiteralTypeFromProperties(type, TypeFlags.StringLiteral) :
                 !noIndexSignatures && getIndexInfoOfType(type, IndexKind.String) ? getUnionType([stringType, numberType, getLiteralTypeFromProperties(type, TypeFlags.UniqueESSymbol)]) :
-                !noIndexSignatures && getNonEnumNumberIndexInfo(type) ? getUnionType([numberType, getLiteralTypeFromProperties(type, TypeFlags.StringLiteral | TypeFlags.UniqueESSymbol)]) :
+                getNonEnumNumberIndexInfo(type) ? getUnionType([numberType, getLiteralTypeFromProperties(type, TypeFlags.StringLiteral | TypeFlags.UniqueESSymbol)]) :
                 getLiteralTypeFromProperties(type, TypeFlags.StringOrNumberLiteralOrUnique);
         }
 
@@ -10066,10 +10066,10 @@ namespace ts {
                 if (objectType.flags & (TypeFlags.Any | TypeFlags.Never)) {
                     return objectType;
                 }
-                const indexInfo = isTypeAssignableToKind(indexType, TypeFlags.NumberLike) && getIndexInfoOfType(objectType, IndexKind.Number) ||
-                    getIndexInfoOfType(objectType, IndexKind.String);
+                const stringIndexInfo = getIndexInfoOfType(objectType, IndexKind.String);
+                const indexInfo = isTypeAssignableToKind(indexType, TypeFlags.NumberLike) && getIndexInfoOfType(objectType, IndexKind.Number) || stringIndexInfo;
                 if (indexInfo) {
-                    if (accessFlags & AccessFlags.NoIndexSignatures) {
+                    if (accessFlags & AccessFlags.NoIndexSignatures && indexInfo === stringIndexInfo) {
                         if (accessExpression) {
                             error(accessExpression, Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(originalObjectType));
                         }
diff --git a/tests/baselines/reference/keyofAndIndexedAccess2.errors.txt b/tests/baselines/reference/keyofAndIndexedAccess2.errors.txt
@@ -194,4 +194,14 @@ tests/cases/conformance/types/keyof/keyofAndIndexedAccess2.ts(108,5): error TS23
     type StrictExclude<T, U> = T extends StrictExtract<T, U> ? never : T;
     type A<T> = { [Q in { [P in keyof T]: P; }[keyof T]]: T[Q]; };
     type B<T, V> = A<{ [Q in keyof T]: StrictExclude<B<T[Q], V>, {}>; }>;
+    
+    // Repros from #30938
+    
+    function fn<T extends {elements: Array<string>} | {elements: Array<number>}>(param: T, cb: (element: T['elements'][number]) => void) {
+        cb(param.elements[0]);
+    }
+    
+    function fn2<T extends Array<string>>(param: T, cb: (element: T[number]) => void) {
+        cb(param[0]);
+    }
     
diff --git a/tests/baselines/reference/keyofAndIndexedAccess2.js b/tests/baselines/reference/keyofAndIndexedAccess2.js
@@ -115,6 +115,16 @@ type StrictExtract<T, U> = T extends U ? U extends T ? T : never : never;
 type StrictExclude<T, U> = T extends StrictExtract<T, U> ? never : T;
 type A<T> = { [Q in { [P in keyof T]: P; }[keyof T]]: T[Q]; };
 type B<T, V> = A<{ [Q in keyof T]: StrictExclude<B<T[Q], V>, {}>; }>;
+
+// Repros from #30938
+
+function fn<T extends {elements: Array<string>} | {elements: Array<number>}>(param: T, cb: (element: T['elements'][number]) => void) {
+    cb(param.elements[0]);
+}
+
+function fn2<T extends Array<string>>(param: T, cb: (element: T[number]) => void) {
+    cb(param[0]);
+}
 
 
 //// [keyofAndIndexedAccess2.js]
@@ -190,3 +200,10 @@ export function getEntity(id, state) {
 function get123() {
     return 123; // Error
 }
+// Repros from #30938
+function fn(param, cb) {
+    cb(param.elements[0]);
+}
+function fn2(param, cb) {
+    cb(param[0]);
+}
diff --git a/tests/baselines/reference/keyofAndIndexedAccess2.symbols b/tests/baselines/reference/keyofAndIndexedAccess2.symbols
@@ -434,3 +434,40 @@ type B<T, V> = A<{ [Q in keyof T]: StrictExclude<B<T[Q], V>, {}>; }>;
 >Q : Symbol(Q, Decl(keyofAndIndexedAccess2.ts, 115, 20))
 >V : Symbol(V, Decl(keyofAndIndexedAccess2.ts, 115, 9))
 
+// Repros from #30938
+
+function fn<T extends {elements: Array<string>} | {elements: Array<number>}>(param: T, cb: (element: T['elements'][number]) => void) {
+>fn : Symbol(fn, Decl(keyofAndIndexedAccess2.ts, 115, 69))
+>T : Symbol(T, Decl(keyofAndIndexedAccess2.ts, 119, 12))
+>elements : Symbol(elements, Decl(keyofAndIndexedAccess2.ts, 119, 23))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 2 more)
+>elements : Symbol(elements, Decl(keyofAndIndexedAccess2.ts, 119, 51))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 2 more)
+>param : Symbol(param, Decl(keyofAndIndexedAccess2.ts, 119, 77))
+>T : Symbol(T, Decl(keyofAndIndexedAccess2.ts, 119, 12))
+>cb : Symbol(cb, Decl(keyofAndIndexedAccess2.ts, 119, 86))
+>element : Symbol(element, Decl(keyofAndIndexedAccess2.ts, 119, 92))
+>T : Symbol(T, Decl(keyofAndIndexedAccess2.ts, 119, 12))
+
+    cb(param.elements[0]);
+>cb : Symbol(cb, Decl(keyofAndIndexedAccess2.ts, 119, 86))
+>param.elements : Symbol(elements, Decl(keyofAndIndexedAccess2.ts, 119, 23), Decl(keyofAndIndexedAccess2.ts, 119, 51))
+>param : Symbol(param, Decl(keyofAndIndexedAccess2.ts, 119, 77))
+>elements : Symbol(elements, Decl(keyofAndIndexedAccess2.ts, 119, 23), Decl(keyofAndIndexedAccess2.ts, 119, 51))
+}
+
+function fn2<T extends Array<string>>(param: T, cb: (element: T[number]) => void) {
+>fn2 : Symbol(fn2, Decl(keyofAndIndexedAccess2.ts, 121, 1))
+>T : Symbol(T, Decl(keyofAndIndexedAccess2.ts, 123, 13))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 2 more)
+>param : Symbol(param, Decl(keyofAndIndexedAccess2.ts, 123, 38))
+>T : Symbol(T, Decl(keyofAndIndexedAccess2.ts, 123, 13))
+>cb : Symbol(cb, Decl(keyofAndIndexedAccess2.ts, 123, 47))
+>element : Symbol(element, Decl(keyofAndIndexedAccess2.ts, 123, 53))
+>T : Symbol(T, Decl(keyofAndIndexedAccess2.ts, 123, 13))
+
+    cb(param[0]);
+>cb : Symbol(cb, Decl(keyofAndIndexedAccess2.ts, 123, 47))
+>param : Symbol(param, Decl(keyofAndIndexedAccess2.ts, 123, 38))
+}
+
diff --git a/tests/baselines/reference/keyofAndIndexedAccess2.types b/tests/baselines/reference/keyofAndIndexedAccess2.types
@@ -437,3 +437,37 @@ type A<T> = { [Q in { [P in keyof T]: P; }[keyof T]]: T[Q]; };
 type B<T, V> = A<{ [Q in keyof T]: StrictExclude<B<T[Q], V>, {}>; }>;
 >B : A<{ [Q in keyof T]: StrictExclude<A<{ [Q in keyof T[Q]]: StrictExclude<A<{ [Q in keyof T[Q][Q]]: StrictExclude<A<{ [Q in keyof T[Q][Q][Q]]: StrictExclude<A<{ [Q in keyof T[Q][Q][Q][Q]]: StrictExclude<A<{ [Q in keyof T[Q][Q][Q][Q][Q]]: StrictExclude<A<{ [Q in keyof T[Q][Q][Q][Q][Q][Q]]: StrictExclude<A<{ [Q in keyof T[Q][Q][Q][Q][Q][Q][Q]]: StrictExclude<A<{ [Q in keyof T[Q][Q][Q][Q][Q][Q][Q][Q]]: StrictExclude<A<{ [Q in keyof T[Q][Q][Q][Q][Q][Q][Q][Q][Q]]: StrictExclude<A<{ [Q in keyof T[Q][Q][Q][Q][Q][Q][Q][Q][Q][Q]]: StrictExclude<A<any>, {}>; }>, {}>; }>, {}>; }>, {}>; }>, {}>; }>, {}>; }>, {}>; }>, {}>; }>, {}>; }>, {}>; }>, {}>; }>
 
+// Repros from #30938
+
+function fn<T extends {elements: Array<string>} | {elements: Array<number>}>(param: T, cb: (element: T['elements'][number]) => void) {
+>fn : <T extends { elements: string[]; } | { elements: number[]; }>(param: T, cb: (element: T["elements"][number]) => void) => void
+>elements : string[]
+>elements : number[]
+>param : T
+>cb : (element: T["elements"][number]) => void
+>element : T["elements"][number]
+
+    cb(param.elements[0]);
+>cb(param.elements[0]) : void
+>cb : (element: T["elements"][number]) => void
+>param.elements[0] : string | number
+>param.elements : string[] | number[]
+>param : T
+>elements : string[] | number[]
+>0 : 0
+}
+
+function fn2<T extends Array<string>>(param: T, cb: (element: T[number]) => void) {
+>fn2 : <T extends string[]>(param: T, cb: (element: T[number]) => void) => void
+>param : T
+>cb : (element: T[number]) => void
+>element : T[number]
+
+    cb(param[0]);
+>cb(param[0]) : void
+>cb : (element: T[number]) => void
+>param[0] : string
+>param : T
+>0 : 0
+}
+
diff --git a/tests/cases/conformance/types/keyof/keyofAndIndexedAccess2.ts b/tests/cases/conformance/types/keyof/keyofAndIndexedAccess2.ts
@@ -117,3 +117,13 @@ type StrictExtract<T, U> = T extends U ? U extends T ? T : never : never;
 type StrictExclude<T, U> = T extends StrictExtract<T, U> ? never : T;
 type A<T> = { [Q in { [P in keyof T]: P; }[keyof T]]: T[Q]; };
 type B<T, V> = A<{ [Q in keyof T]: StrictExclude<B<T[Q], V>, {}>; }>;
+
+// Repros from #30938
+
+function fn<T extends {elements: Array<string>} | {elements: Array<number>}>(param: T, cb: (element: T['elements'][number]) => void) {
+    cb(param.elements[0]);
+}
+
+function fn2<T extends Array<string>>(param: T, cb: (element: T[number]) => void) {
+    cb(param[0]);
+}
