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
|
//// [collectionPatternNoError.ts]
interface MsgConstructor<T extends Message> {
new(data: Array<{}>): T;
}
class Message {
clone(): this {
return this;
}
}
interface MessageList<T extends Message> extends Message {
methodOnMessageList(): T[];
}
function fetchMsg<V extends Message>(protoCtor: MsgConstructor<V>): V {
return null!;
}
class DataProvider<T extends Message, U extends MessageList<T>> {
constructor(
private readonly message: MsgConstructor<T>,
private readonly messageList: MsgConstructor<U>,
) { }
fetch() {
const messageList = fetchMsg(this.messageList);
messageList.methodOnMessageList();
}
}
// The same bug as the above but using indexed accesses
// (won't surface directly unless unsound indexed access assignments are forbidden)
function f<
U extends {TType: MessageList<T>},
T extends Message
>(message: MsgConstructor<T>, messageList: MsgConstructor<U["TType"]>) {
fetchMsg(messageList).methodOnMessageList();
}
//// [collectionPatternNoError.js]
var Message = /** @class */ (function () {
function Message() {
}
Message.prototype.clone = function () {
return this;
};
return Message;
}());
function fetchMsg(protoCtor) {
return null;
}
var DataProvider = /** @class */ (function () {
function DataProvider(message, messageList) {
this.message = message;
this.messageList = messageList;
}
DataProvider.prototype.fetch = function () {
var messageList = fetchMsg(this.messageList);
messageList.methodOnMessageList();
};
return DataProvider;
}());
// The same bug as the above but using indexed accesses
// (won't surface directly unless unsound indexed access assignments are forbidden)
function f(message, messageList) {
fetchMsg(messageList).methodOnMessageList();
}
|
