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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
//// [subtypingWithCallSignatures3.ts]
// checking subtype relations for function types as it relates to contextual signature instantiation
// error cases, so function calls will all result in 'any'
module Errors {
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
class OtherDerived extends Base { bing: string; }
declare function foo2(a2: (x: number) => string[]): typeof a2;
declare function foo2(a2: any): any;
declare function foo7(a2: (x: (arg: Base) => Derived) => (r: Base) => Derived2): typeof a2;
declare function foo7(a2: any): any;
declare function foo8(a2: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived): typeof a2;
declare function foo8(a2: any): any;
declare function foo10(a2: (...x: Base[]) => Base): typeof a2;
declare function foo10(a2: any): any;
declare function foo11(a2: (x: { foo: string }, y: { foo: string; bar: string }) => Base): typeof a2;
declare function foo11(a2: any): any;
declare function foo12(a2: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>): typeof a2;
declare function foo12(a2: any): any;
declare function foo15(a2: (x: { a: string; b: number }) => number): typeof a2;
declare function foo15(a2: any): any;
declare function foo16(a2: {
// type of parameter is overload set which means we can't do inference based on this type
(x: {
(a: number): number;
(a?: number): number;
}): number[];
(x: {
(a: boolean): boolean;
(a?: boolean): boolean;
}): boolean[];
}): typeof a2;
declare function foo16(a2: any): any;
declare function foo17(a2: {
(x: {
<T extends Derived>(a: T): T;
<T extends Base>(a: T): T;
}): any[];
(x: {
<T extends Derived2>(a: T): T;
<T extends Base>(a: T): T;
}): any[];
}): typeof a2;
declare function foo17(a2: any): any;
var r1 = foo2(<T, U>(x: T) => <U[]>null); // any
var r1a = [(x: number) => [''], <T, U>(x: T) => <U[]>null];
var r1b = [<T, U>(x: T) => <U[]>null, (x: number) => ['']];
var r2arg = <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => <V>null;
var r2arg2 = (x: (arg: Base) => Derived) => (r: Base) => <Derived2>null;
var r2 = foo7(r2arg); // any
var r2a = [r2arg2, r2arg];
var r2b = [r2arg, r2arg2];
var r3arg = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => <U>null;
var r3arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null;
var r3 = foo8(r3arg); // any
var r3a = [r3arg2, r3arg];
var r3b = [r3arg, r3arg2];
var r4arg = <T extends Derived>(...x: T[]) => <T>null;
var r4arg2 = (...x: Base[]) => <Base>null;
var r4 = foo10(r4arg); // any
var r4a = [r4arg2, r4arg];
var r4b = [r4arg, r4arg2];
var r5arg = <T extends Derived>(x: T, y: T) => <T>null;
var r5arg2 = (x: { foo: string }, y: { foo: string; bar: string }) => <Base>null;
var r5 = foo11(r5arg); // any
var r5a = [r5arg2, r5arg];
var r5b = [r5arg, r5arg2];
var r6arg = (x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null;
var r6arg2 = <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => <T>null;
var r6 = foo12(r6arg); // (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
var r6a = [r6arg2, r6arg];
var r6b = [r6arg, r6arg2];
var r7arg = <T>(x: { a: T; b: T }) => <T>null;
var r7arg2 = (x: { a: string; b: number }) => 1;
var r7 = foo15(r7arg); // any
var r7a = [r7arg2, r7arg];
var r7b = [r7arg, r7arg2];
var r7arg3 = <T extends Base>(x: { a: T; b: T }) => 1;
var r7c = foo15(r7arg3); // (x: { a: string; b: number }) => number): number;
var r7d = [r7arg2, r7arg3];
var r7e = [r7arg3, r7arg2];
var r8arg = <T>(x: (a: T) => T) => <T[]>null;
var r8 = foo16(r8arg); // any
var r9arg = <T>(x: (a: T) => T) => <any[]>null;
var r9 = foo17(r9arg); // (x: { <T extends Derived >(a: T): T; <T extends Base >(a: T): T; }): any[]; (x: { <T extends Derived2>(a: T): T; <T extends Base>(a: T): T; }): any[];
}
module WithGenericSignaturesInBaseType {
declare function foo2(a2: <T>(x: T) => T[]): typeof a2;
declare function foo2(a2: any): any;
var r2arg2 = <T>(x: T) => [''];
var r2 = foo2(r2arg2); // <T>(x:T) => T[] since we can infer from generic signatures now
declare function foo3(a2: <T>(x: T) => string[]): typeof a2;
declare function foo3(a2: any): any;
var r3arg2 = <T>(x: T) => <T[]>null;
var r3 = foo3(r3arg2); // any
}
//// [subtypingWithCallSignatures3.js]
// checking subtype relations for function types as it relates to contextual signature instantiation
// error cases, so function calls will all result in 'any'
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var Errors;
(function (Errors) {
var Base = /** @class */ (function () {
function Base() {
}
return Base;
}());
var Derived = /** @class */ (function (_super) {
__extends(Derived, _super);
function Derived() {
return _super !== null && _super.apply(this, arguments) || this;
}
return Derived;
}(Base));
var Derived2 = /** @class */ (function (_super) {
__extends(Derived2, _super);
function Derived2() {
return _super !== null && _super.apply(this, arguments) || this;
}
return Derived2;
}(Derived));
var OtherDerived = /** @class */ (function (_super) {
__extends(OtherDerived, _super);
function OtherDerived() {
return _super !== null && _super.apply(this, arguments) || this;
}
return OtherDerived;
}(Base));
var r1 = foo2(function (x) { return null; }); // any
var r1a = [function (x) { return ['']; }, function (x) { return null; }];
var r1b = [function (x) { return null; }, function (x) { return ['']; }];
var r2arg = function (x) { return function (r) { return null; }; };
var r2arg2 = function (x) { return function (r) { return null; }; };
var r2 = foo7(r2arg); // any
var r2a = [r2arg2, r2arg];
var r2b = [r2arg, r2arg2];
var r3arg = function (x, y) { return function (r) { return null; }; };
var r3arg2 = function (x, y) { return function (r) { return null; }; };
var r3 = foo8(r3arg); // any
var r3a = [r3arg2, r3arg];
var r3b = [r3arg, r3arg2];
var r4arg = function () {
var x = [];
for (var _i = 0; _i < arguments.length; _i++) {
x[_i] = arguments[_i];
}
return null;
};
var r4arg2 = function () {
var x = [];
for (var _i = 0; _i < arguments.length; _i++) {
x[_i] = arguments[_i];
}
return null;
};
var r4 = foo10(r4arg); // any
var r4a = [r4arg2, r4arg];
var r4b = [r4arg, r4arg2];
var r5arg = function (x, y) { return null; };
var r5arg2 = function (x, y) { return null; };
var r5 = foo11(r5arg); // any
var r5a = [r5arg2, r5arg];
var r5b = [r5arg, r5arg2];
var r6arg = function (x, y) { return null; };
var r6arg2 = function (x, y) { return null; };
var r6 = foo12(r6arg); // (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
var r6a = [r6arg2, r6arg];
var r6b = [r6arg, r6arg2];
var r7arg = function (x) { return null; };
var r7arg2 = function (x) { return 1; };
var r7 = foo15(r7arg); // any
var r7a = [r7arg2, r7arg];
var r7b = [r7arg, r7arg2];
var r7arg3 = function (x) { return 1; };
var r7c = foo15(r7arg3); // (x: { a: string; b: number }) => number): number;
var r7d = [r7arg2, r7arg3];
var r7e = [r7arg3, r7arg2];
var r8arg = function (x) { return null; };
var r8 = foo16(r8arg); // any
var r9arg = function (x) { return null; };
var r9 = foo17(r9arg); // (x: { <T extends Derived >(a: T): T; <T extends Base >(a: T): T; }): any[]; (x: { <T extends Derived2>(a: T): T; <T extends Base>(a: T): T; }): any[];
})(Errors || (Errors = {}));
var WithGenericSignaturesInBaseType;
(function (WithGenericSignaturesInBaseType) {
var r2arg2 = function (x) { return ['']; };
var r2 = foo2(r2arg2); // <T>(x:T) => T[] since we can infer from generic signatures now
var r3arg2 = function (x) { return null; };
var r3 = foo3(r3arg2); // any
})(WithGenericSignaturesInBaseType || (WithGenericSignaturesInBaseType = {}));
|
