Skip to content

Commit de669cf

Browse files
weswighamweswigham
authored
Only include unique symbols when getting index types for access checks (#23145)
* Only include unique symbols when getting index types for access checks * Filter all nonstrings * Inline ternary
1 parent 7dc9147 commit de669cf

7 files changed

+322
-13
lines changed

‎src/compiler/checker.ts

Lines changed: 22 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -8114,12 +8114,16 @@ namespace ts {
81148114
return links.resolvedType;
81158115
}
81168116

8117-
function getIndexTypeForGenericType(type: InstantiableType | UnionOrIntersectionType) {
8118-
if (!type.resolvedIndexType) {
8119-
type.resolvedIndexType = <IndexType>createType(TypeFlags.Index);
8120-
type.resolvedIndexType.type = type;
8117+
function getIndexTypeForGenericType(type: InstantiableType | UnionOrIntersectionType, includeDeclaredTypes?: boolean) {
8118+
const cacheLocation = includeDeclaredTypes ? "resolvedDeclaredIndexType" : "resolvedIndexType";
8119+
if (!type[cacheLocation]) {
8120+
type[cacheLocation] = <IndexType>createType(TypeFlags.Index);
8121+
type[cacheLocation].type = type;
8122+
if (includeDeclaredTypes) {
8123+
type[cacheLocation].isDeclaredType = true;
8124+
}
81218125
}
8122-
return type.resolvedIndexType;
8126+
return type[cacheLocation];
81238127
}
81248128

81258129
function getLiteralTypeFromPropertyName(prop: Symbol) {
@@ -8137,17 +8141,22 @@ namespace ts {
81378141
return links.nameType;
81388142
}
81398143

8140-
function getLiteralTypeFromPropertyNames(type: Type) {
8141-
return getUnionType(map(getPropertiesOfType(type), getLiteralTypeFromPropertyName));
8144+
function isTypeString(type: Type) {
8145+
return isTypeAssignableToKind(type, TypeFlags.StringLike);
8146+
}
8147+
8148+
function getLiteralTypeFromPropertyNames(type: Type, includeDeclaredTypes?: boolean) {
8149+
const originalKeys = map(getPropertiesOfType(type), getLiteralTypeFromPropertyName);
8150+
return getUnionType(includeDeclaredTypes ? originalKeys : filter(originalKeys, isTypeString));
81428151
}
81438152

8144-
function getIndexType(type: Type): Type {
8145-
return type.flags & TypeFlags.Intersection ? getUnionType(map((<IntersectionType>type).types, t => getIndexType(t))) :
8146-
maybeTypeOfKind(type, TypeFlags.InstantiableNonPrimitive) ? getIndexTypeForGenericType(<InstantiableType | UnionOrIntersectionType>type) :
8153+
function getIndexType(type: Type, includeDeclaredTypes?: boolean): Type {
8154+
return type.flags & TypeFlags.Intersection ? getUnionType(map((<IntersectionType>type).types, t => getIndexType(t, includeDeclaredTypes))) :
8155+
maybeTypeOfKind(type, TypeFlags.InstantiableNonPrimitive) ? getIndexTypeForGenericType(<InstantiableType | UnionOrIntersectionType>type, includeDeclaredTypes) :
81478156
getObjectFlags(type) & ObjectFlags.Mapped ? getConstraintTypeFromMappedType(<MappedType>type) :
81488157
type === wildcardType ? wildcardType :
81498158
type.flags & TypeFlags.Any || getIndexInfoOfType(type, IndexKind.String) ? stringType :
8150-
getLiteralTypeFromPropertyNames(type);
8159+
getLiteralTypeFromPropertyNames(type, includeDeclaredTypes);
81518160
}
81528161

81538162
function getIndexTypeOrString(type: Type): Type {
@@ -10323,7 +10332,7 @@ namespace ts {
1032310332
// constraint of T.
1032410333
const constraint = getConstraintForRelation((<IndexType>target).type);
1032510334
if (constraint) {
10326-
if (result = isRelatedTo(source, getIndexType(constraint), reportErrors)) {
10335+
if (result = isRelatedTo(source, getIndexType(constraint, (target as IndexType).isDeclaredType), reportErrors)) {
1032710336
return result;
1032810337
}
1032910338
}
@@ -20871,7 +20880,7 @@ namespace ts {
2087120880
// Check if the index type is assignable to 'keyof T' for the object type.
2087220881
const objectType = (<IndexedAccessType>type).objectType;
2087320882
const indexType = (<IndexedAccessType>type).indexType;
20874-
if (isTypeAssignableTo(indexType, getIndexType(objectType))) {
20883+
if (isTypeAssignableTo(indexType, getIndexType(objectType, /*includeDeclaredTypes*/ true))) {
2087520884
if (accessNode.kind === SyntaxKind.ElementAccessExpression && isAssignmentTarget(accessNode) &&
2087620885
getObjectFlags(objectType) & ObjectFlags.Mapped && getMappedTypeModifiers(<MappedType>objectType) & MappedTypeModifiers.IncludeReadonly) {
2087720886
error(accessNode, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));

‎src/compiler/types.ts

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3753,6 +3753,8 @@ namespace ts {
37533753
/* @internal */
37543754
resolvedIndexType: IndexType;
37553755
/* @internal */
3756+
resolvedDeclaredIndexType: IndexType;
3757+
/* @internal */
37563758
resolvedBaseConstraint: Type;
37573759
/* @internal */
37583760
couldContainTypeVariables: boolean;
@@ -3839,6 +3841,8 @@ namespace ts {
38393841
resolvedBaseConstraint?: Type;
38403842
/* @internal */
38413843
resolvedIndexType?: IndexType;
3844+
/* @internal */
3845+
resolvedDeclaredIndexType?: IndexType;
38423846
}
38433847

38443848
// Type parameters (TypeFlags.TypeParameter)
@@ -3870,6 +3874,8 @@ namespace ts {
38703874

38713875
// keyof T types (TypeFlags.Index)
38723876
export interface IndexType extends InstantiableType {
3877+
/* @internal */
3878+
isDeclaredType?: boolean;
38733879
type: InstantiableType | UnionOrIntersectionType;
38743880
}
38753881

‎tests/baselines/reference/keyofDoesntContainSymbols.errors.txt

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
tests/cases/compiler/keyofDoesntContainSymbols.ts(11,30): error TS2345: Argument of type '""' is not assignable to parameter of type 'number'.
2+
tests/cases/compiler/keyofDoesntContainSymbols.ts(14,23): error TS2345: Argument of type 'unique symbol' is not assignable to parameter of type '"str" | "num"'.
3+
tests/cases/compiler/keyofDoesntContainSymbols.ts(17,23): error TS2345: Argument of type '0' is not assignable to parameter of type '"str" | "num"'.
4+
5+
6+
==== tests/cases/compiler/keyofDoesntContainSymbols.ts (3 errors) ====
7+
const sym = Symbol();
8+
const num = 0;
9+
const obj = { num: 0, str: 's', [num]: num as 0, [sym]: sym };
10+
11+
function set <T extends object, K extends keyof T> (obj: T, key: K, value: T[K]): T[K] {
12+
return obj[key] = value;
13+
}
14+
15+
const val = set(obj, 'str', '');
16+
// string
17+
const valB = set(obj, 'num', '');
18+
~~
19+
!!! error TS2345: Argument of type '""' is not assignable to parameter of type 'number'.
20+
// Expect type error
21+
// Argument of type '""' is not assignable to parameter of type 'number'.
22+
const valC = set(obj, sym, sym);
23+
~~~
24+
!!! error TS2345: Argument of type 'unique symbol' is not assignable to parameter of type '"str" | "num"'.
25+
// Expect type error
26+
// Argument of type 'unique symbol' is not assignable to parameter of type "str" | "num"
27+
const valD = set(obj, num, num);
28+
~~~
29+
!!! error TS2345: Argument of type '0' is not assignable to parameter of type '"str" | "num"'.
30+
// Expect type error
31+
// Argument of type '0' is not assignable to parameter of type "str" | "num"
32+
type KeyofObj = keyof typeof obj;
33+
// "str" | "num"
34+
type Values<T> = T[keyof T];
35+
36+
type ValuesOfObj = Values<typeof obj>;

‎tests/baselines/reference/keyofDoesntContainSymbols.js

Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
//// [keyofDoesntContainSymbols.ts]
2+
const sym = Symbol();
3+
const num = 0;
4+
const obj = { num: 0, str: 's', [num]: num as 0, [sym]: sym };
5+
6+
function set <T extends object, K extends keyof T> (obj: T, key: K, value: T[K]): T[K] {
7+
return obj[key] = value;
8+
}
9+
10+
const val = set(obj, 'str', '');
11+
// string
12+
const valB = set(obj, 'num', '');
13+
// Expect type error
14+
// Argument of type '""' is not assignable to parameter of type 'number'.
15+
const valC = set(obj, sym, sym);
16+
// Expect type error
17+
// Argument of type 'unique symbol' is not assignable to parameter of type "str" | "num"
18+
const valD = set(obj, num, num);
19+
// Expect type error
20+
// Argument of type '0' is not assignable to parameter of type "str" | "num"
21+
type KeyofObj = keyof typeof obj;
22+
// "str" | "num"
23+
type Values<T> = T[keyof T];
24+
25+
type ValuesOfObj = Values<typeof obj>;
26+
27+
//// [keyofDoesntContainSymbols.js]
28+
var sym = Symbol();
29+
var num = 0;
30+
var obj = (_a = { num: 0, str: 's' }, _a[num] = num, _a[sym] = sym, _a);
31+
function set(obj, key, value) {
32+
return obj[key] = value;
33+
}
34+
var val = set(obj, 'str', '');
35+
// string
36+
var valB = set(obj, 'num', '');
37+
// Expect type error
38+
// Argument of type '""' is not assignable to parameter of type 'number'.
39+
var valC = set(obj, sym, sym);
40+
// Expect type error
41+
// Argument of type 'unique symbol' is not assignable to parameter of type "str" | "num"
42+
var valD = set(obj, num, num);
43+
var _a;

‎tests/baselines/reference/keyofDoesntContainSymbols.symbols

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
=== tests/cases/compiler/keyofDoesntContainSymbols.ts ===
2+
const sym = Symbol();
3+
>sym : Symbol(sym, Decl(keyofDoesntContainSymbols.ts, 0, 5))
4+
>Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
5+
6+
const num = 0;
7+
>num : Symbol(num, Decl(keyofDoesntContainSymbols.ts, 1, 5))
8+
9+
const obj = { num: 0, str: 's', [num]: num as 0, [sym]: sym };
10+
>obj : Symbol(obj, Decl(keyofDoesntContainSymbols.ts, 2, 5))
11+
>num : Symbol(num, Decl(keyofDoesntContainSymbols.ts, 2, 13))
12+
>str : Symbol(str, Decl(keyofDoesntContainSymbols.ts, 2, 21))
13+
>[num] : Symbol([num], Decl(keyofDoesntContainSymbols.ts, 2, 31))
14+
>num : Symbol(num, Decl(keyofDoesntContainSymbols.ts, 1, 5))
15+
>num : Symbol(num, Decl(keyofDoesntContainSymbols.ts, 1, 5))
16+
>[sym] : Symbol([sym], Decl(keyofDoesntContainSymbols.ts, 2, 48))
17+
>sym : Symbol(sym, Decl(keyofDoesntContainSymbols.ts, 0, 5))
18+
>sym : Symbol(sym, Decl(keyofDoesntContainSymbols.ts, 0, 5))
19+
20+
function set <T extends object, K extends keyof T> (obj: T, key: K, value: T[K]): T[K] {
21+
>set : Symbol(set, Decl(keyofDoesntContainSymbols.ts, 2, 62))
22+
>T : Symbol(T, Decl(keyofDoesntContainSymbols.ts, 4, 14))
23+
>K : Symbol(K, Decl(keyofDoesntContainSymbols.ts, 4, 31))
24+
>T : Symbol(T, Decl(keyofDoesntContainSymbols.ts, 4, 14))
25+
>obj : Symbol(obj, Decl(keyofDoesntContainSymbols.ts, 4, 52))
26+
>T : Symbol(T, Decl(keyofDoesntContainSymbols.ts, 4, 14))
27+
>key : Symbol(key, Decl(keyofDoesntContainSymbols.ts, 4, 59))
28+
>K : Symbol(K, Decl(keyofDoesntContainSymbols.ts, 4, 31))
29+
>value : Symbol(value, Decl(keyofDoesntContainSymbols.ts, 4, 67))
30+
>T : Symbol(T, Decl(keyofDoesntContainSymbols.ts, 4, 14))
31+
>K : Symbol(K, Decl(keyofDoesntContainSymbols.ts, 4, 31))
32+
>T : Symbol(T, Decl(keyofDoesntContainSymbols.ts, 4, 14))
33+
>K : Symbol(K, Decl(keyofDoesntContainSymbols.ts, 4, 31))
34+
35+
return obj[key] = value;
36+
>obj : Symbol(obj, Decl(keyofDoesntContainSymbols.ts, 4, 52))
37+
>key : Symbol(key, Decl(keyofDoesntContainSymbols.ts, 4, 59))
38+
>value : Symbol(value, Decl(keyofDoesntContainSymbols.ts, 4, 67))
39+
}
40+
41+
const val = set(obj, 'str', '');
42+
>val : Symbol(val, Decl(keyofDoesntContainSymbols.ts, 8, 5))
43+
>set : Symbol(set, Decl(keyofDoesntContainSymbols.ts, 2, 62))
44+
>obj : Symbol(obj, Decl(keyofDoesntContainSymbols.ts, 2, 5))
45+
46+
// string
47+
const valB = set(obj, 'num', '');
48+
>valB : Symbol(valB, Decl(keyofDoesntContainSymbols.ts, 10, 5))
49+
>set : Symbol(set, Decl(keyofDoesntContainSymbols.ts, 2, 62))
50+
>obj : Symbol(obj, Decl(keyofDoesntContainSymbols.ts, 2, 5))
51+
52+
// Expect type error
53+
// Argument of type '""' is not assignable to parameter of type 'number'.
54+
const valC = set(obj, sym, sym);
55+
>valC : Symbol(valC, Decl(keyofDoesntContainSymbols.ts, 13, 5))
56+
>set : Symbol(set, Decl(keyofDoesntContainSymbols.ts, 2, 62))
57+
>obj : Symbol(obj, Decl(keyofDoesntContainSymbols.ts, 2, 5))
58+
>sym : Symbol(sym, Decl(keyofDoesntContainSymbols.ts, 0, 5))
59+
>sym : Symbol(sym, Decl(keyofDoesntContainSymbols.ts, 0, 5))
60+
61+
// Expect type error
62+
// Argument of type 'unique symbol' is not assignable to parameter of type "str" | "num"
63+
const valD = set(obj, num, num);
64+
>valD : Symbol(valD, Decl(keyofDoesntContainSymbols.ts, 16, 5))
65+
>set : Symbol(set, Decl(keyofDoesntContainSymbols.ts, 2, 62))
66+
>obj : Symbol(obj, Decl(keyofDoesntContainSymbols.ts, 2, 5))
67+
>num : Symbol(num, Decl(keyofDoesntContainSymbols.ts, 1, 5))
68+
>num : Symbol(num, Decl(keyofDoesntContainSymbols.ts, 1, 5))
69+
70+
// Expect type error
71+
// Argument of type '0' is not assignable to parameter of type "str" | "num"
72+
type KeyofObj = keyof typeof obj;
73+
>KeyofObj : Symbol(KeyofObj, Decl(keyofDoesntContainSymbols.ts, 16, 32))
74+
>obj : Symbol(obj, Decl(keyofDoesntContainSymbols.ts, 2, 5))
75+
76+
// "str" | "num"
77+
type Values<T> = T[keyof T];
78+
>Values : Symbol(Values, Decl(keyofDoesntContainSymbols.ts, 19, 33))
79+
>T : Symbol(T, Decl(keyofDoesntContainSymbols.ts, 21, 12))
80+
>T : Symbol(T, Decl(keyofDoesntContainSymbols.ts, 21, 12))
81+
>T : Symbol(T, Decl(keyofDoesntContainSymbols.ts, 21, 12))
82+
83+
type ValuesOfObj = Values<typeof obj>;
84+
>ValuesOfObj : Symbol(ValuesOfObj, Decl(keyofDoesntContainSymbols.ts, 21, 28))
85+
>Values : Symbol(Values, Decl(keyofDoesntContainSymbols.ts, 19, 33))
86+
>obj : Symbol(obj, Decl(keyofDoesntContainSymbols.ts, 2, 5))
87+

‎tests/baselines/reference/keyofDoesntContainSymbols.types

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,103 @@
1+
=== tests/cases/compiler/keyofDoesntContainSymbols.ts ===
2+
const sym = Symbol();
3+
>sym : unique symbol
4+
>Symbol() : unique symbol
5+
>Symbol : SymbolConstructor
6+
7+
const num = 0;
8+
>num : 0
9+
>0 : 0
10+
11+
const obj = { num: 0, str: 's', [num]: num as 0, [sym]: sym };
12+
>obj : { num: number; str: string; [num]: 0; [sym]: symbol; }
13+
>{ num: 0, str: 's', [num]: num as 0, [sym]: sym } : { num: number; str: string; [num]: 0; [sym]: symbol; }
14+
>num : number
15+
>0 : 0
16+
>str : string
17+
>'s' : "s"
18+
>[num] : 0
19+
>num : 0
20+
>num as 0 : 0
21+
>num : 0
22+
>[sym] : symbol
23+
>sym : unique symbol
24+
>sym : unique symbol
25+
26+
function set <T extends object, K extends keyof T> (obj: T, key: K, value: T[K]): T[K] {
27+
>set : <T extends object, K extends keyof T>(obj: T, key: K, value: T[K]) => T[K]
28+
>T : T
29+
>K : K
30+
>T : T
31+
>obj : T
32+
>T : T
33+
>key : K
34+
>K : K
35+
>value : T[K]
36+
>T : T
37+
>K : K
38+
>T : T
39+
>K : K
40+
41+
return obj[key] = value;
42+
>obj[key] = value : T[K]
43+
>obj[key] : T[K]
44+
>obj : T
45+
>key : K
46+
>value : T[K]
47+
}
48+
49+
const val = set(obj, 'str', '');
50+
>val : string
51+
>set(obj, 'str', '') : string
52+
>set : <T extends object, K extends keyof T>(obj: T, key: K, value: T[K]) => T[K]
53+
>obj : { num: number; str: string; [num]: 0; [sym]: symbol; }
54+
>'str' : "str"
55+
>'' : ""
56+
57+
// string
58+
const valB = set(obj, 'num', '');
59+
>valB : any
60+
>set(obj, 'num', '') : any
61+
>set : <T extends object, K extends keyof T>(obj: T, key: K, value: T[K]) => T[K]
62+
>obj : { num: number; str: string; [num]: 0; [sym]: symbol; }
63+
>'num' : "num"
64+
>'' : ""
65+
66+
// Expect type error
67+
// Argument of type '""' is not assignable to parameter of type 'number'.
68+
const valC = set(obj, sym, sym);
69+
>valC : any
70+
>set(obj, sym, sym) : any
71+
>set : <T extends object, K extends keyof T>(obj: T, key: K, value: T[K]) => T[K]
72+
>obj : { num: number; str: string; [num]: 0; [sym]: symbol; }
73+
>sym : unique symbol
74+
>sym : unique symbol
75+
76+
// Expect type error
77+
// Argument of type 'unique symbol' is not assignable to parameter of type "str" | "num"
78+
const valD = set(obj, num, num);
79+
>valD : any
80+
>set(obj, num, num) : any
81+
>set : <T extends object, K extends keyof T>(obj: T, key: K, value: T[K]) => T[K]
82+
>obj : { num: number; str: string; [num]: 0; [sym]: symbol; }
83+
>num : 0
84+
>num : 0
85+
86+
// Expect type error
87+
// Argument of type '0' is not assignable to parameter of type "str" | "num"
88+
type KeyofObj = keyof typeof obj;
89+
>KeyofObj : "str" | "num"
90+
>obj : { num: number; str: string; [num]: 0; [sym]: symbol; }
91+
92+
// "str" | "num"
93+
type Values<T> = T[keyof T];
94+
>Values : T[keyof T]
95+
>T : T
96+
>T : T
97+
>T : T
98+
99+
type ValuesOfObj = Values<typeof obj>;
100+
>ValuesOfObj : string | number
101+
>Values : T[keyof T]
102+
>obj : { num: number; str: string; [num]: 0; [sym]: symbol; }
103+

‎tests/cases/compiler/keyofDoesntContainSymbols.ts

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
// @lib: es6
2+
const sym = Symbol();
3+
const num = 0;
4+
const obj = { num: 0, str: 's', [num]: num as 0, [sym]: sym };
5+
6+
function set <T extends object, K extends keyof T> (obj: T, key: K, value: T[K]): T[K] {
7+
return obj[key] = value;
8+
}
9+
10+
const val = set(obj, 'str', '');
11+
// string
12+
const valB = set(obj, 'num', '');
13+
// Expect type error
14+
// Argument of type '""' is not assignable to parameter of type 'number'.
15+
const valC = set(obj, sym, sym);
16+
// Expect type error
17+
// Argument of type 'unique symbol' is not assignable to parameter of type "str" | "num"
18+
const valD = set(obj, num, num);
19+
// Expect type error
20+
// Argument of type '0' is not assignable to parameter of type "str" | "num"
21+
type KeyofObj = keyof typeof obj;
22+
// "str" | "num"
23+
type Values<T> = T[keyof T];
24+
25+
type ValuesOfObj = Values<typeof obj>;

0 commit comments

Comments
 (0)