1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithStringIndexer.ts ===
// index signatures must be compatible in assignments
interface Base { foo: string; }
>foo : string
interface Derived extends Base { bar: string; }
>bar : string
interface Derived2 extends Derived { baz: string; }
>baz : string
class A {
>A : A
[x: string]: Base;
>x : string
}
var a: A;
>a : A
var b: { [x: string]: Derived; }
>b : { [x: string]: Derived; }
>x : string
a = b; // ok
>a = b : { [x: string]: Derived; }
>a : A
>b : { [x: string]: Derived; }
b = a; // error
>b = a : A
>b : { [x: string]: Derived; }
>a : A
var b2: { [x: string]: Derived2; }
>b2 : { [x: string]: Derived2; }
>x : string
a = b2; // ok
>a = b2 : { [x: string]: Derived2; }
>a : A
>b2 : { [x: string]: Derived2; }
b2 = a; // error
>b2 = a : A
>b2 : { [x: string]: Derived2; }
>a : A
module Generics {
>Generics : typeof Generics
class A<T extends Base> {
>A : A<T>
[x: string]: T;
>x : string
}
class B extends A<Base> {
>B : B
>A : A<Base>
[x: string]: Derived; // ok
>x : string
}
var b1: { [x: string]: Derived; };
>b1 : { [x: string]: Derived; }
>x : string
var a1: A<Base>;
>a1 : A<Base>
a1 = b1; // ok
>a1 = b1 : { [x: string]: Derived; }
>a1 : A<Base>
>b1 : { [x: string]: Derived; }
b1 = a1; // error
>b1 = a1 : A<Base>
>b1 : { [x: string]: Derived; }
>a1 : A<Base>
class B2 extends A<Base> {
>B2 : B2
>A : A<Base>
[x: string]: Derived2; // ok
>x : string
}
var b2: { [x: string]: Derived2; };
>b2 : { [x: string]: Derived2; }
>x : string
a1 = b2; // ok
>a1 = b2 : { [x: string]: Derived2; }
>a1 : A<Base>
>b2 : { [x: string]: Derived2; }
b2 = a1; // error
>b2 = a1 : A<Base>
>b2 : { [x: string]: Derived2; }
>a1 : A<Base>
function foo<T extends Base>() {
>foo : <T extends Base>() => void
var b3: { [x: string]: Derived; };
>b3 : { [x: string]: Derived; }
>x : string
var a3: A<T>;
>a3 : A<T>
a3 = b3; // error
>a3 = b3 : { [x: string]: Derived; }
>a3 : A<T>
>b3 : { [x: string]: Derived; }
b3 = a3; // error
>b3 = a3 : A<T>
>b3 : { [x: string]: Derived; }
>a3 : A<T>
var b4: { [x: string]: Derived2; };
>b4 : { [x: string]: Derived2; }
>x : string
a3 = b4; // error
>a3 = b4 : { [x: string]: Derived2; }
>a3 : A<T>
>b4 : { [x: string]: Derived2; }
b4 = a3; // error
>b4 = a3 : A<T>
>b4 : { [x: string]: Derived2; }
>a3 : A<T>
}
}
|
