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
|
//// [tests/cases/compiler/unusedInvalidTypeArguments.ts] ////
//// [typeReference.ts]
// Tests that types are marked as used, even if used in places that don't accept type arguments.
type N = number;
type U = number;
export type Z = U<N>;
//// [classReference.ts]
type N = number;
class C { }
// This uses getTypeFromClassOrInterfaceReference instead of getTypeFromTypeAliasReference.
export class D extends C<N> {}
//// [interface.ts]
import { Foo } from "unknown";
export interface I<T> { x: Foo<T>; }
//// [call.ts]
import { foo } from "unknown";
type T = number;
foo<T>();
//// [new.ts]
import { Foo } from "unkown";
type T = number;
new Foo<T>();
//// [callAny.ts]
declare var g: any;
type U = number;
g<U>();
g<InvalidReference>(); // Should get error for type argument
//// [super.ts]
import { A, B } from "unknown";
type T = number;
export class C extends A<B> {
m() {
super.m<T>(1);
super.m<InvalidReference>(); // Should get error for type argument
}
}
//// [typeReference.js]
"use strict";
// Tests that types are marked as used, even if used in places that don't accept type arguments.
Object.defineProperty(exports, "__esModule", { value: true });
//// [classReference.js]
"use strict";
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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.D = void 0;
var C = /** @class */ (function () {
function C() {
}
return C;
}());
// This uses getTypeFromClassOrInterfaceReference instead of getTypeFromTypeAliasReference.
var D = /** @class */ (function (_super) {
__extends(D, _super);
function D() {
return _super !== null && _super.apply(this, arguments) || this;
}
return D;
}(C));
exports.D = D;
//// [interface.js]
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
//// [call.js]
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var unknown_1 = require("unknown");
(0, unknown_1.foo)();
//// [new.js]
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var unkown_1 = require("unkown");
new unkown_1.Foo();
//// [callAny.js]
g();
g(); // Should get error for type argument
//// [super.js]
"use strict";
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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.C = void 0;
var unknown_1 = require("unknown");
var C = /** @class */ (function (_super) {
__extends(C, _super);
function C() {
return _super !== null && _super.apply(this, arguments) || this;
}
C.prototype.m = function () {
_super.prototype.m.call(this, 1);
_super.prototype.m.call(this); // Should get error for type argument
};
return C;
}(unknown_1.A));
exports.C = C;
|
