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
|
//// [declarationEmitExpressionInExtends3.ts]
export class ExportedClass<T> {
x: T;
}
class LocalClass<T, U> {
x: T;
y: U;
}
export interface ExportedInterface {
x: number;
}
interface LocalInterface {
x: number;
}
function getLocalClass<T>(c: T) {
return LocalClass;
}
function getExportedClass<T>(c: T) {
return ExportedClass;
}
export class MyClass extends getLocalClass<LocalInterface>(undefined)<string, number> { // error LocalClass is inaccisible
}
export class MyClass2 extends getExportedClass<LocalInterface>(undefined)<string> { // OK
}
export class MyClass3 extends getExportedClass<LocalInterface>(undefined)<LocalInterface> { // Error LocalInterface is inaccisble
}
export class MyClass4 extends getExportedClass<LocalInterface>(undefined)<ExportedInterface> { // OK
}
//// [declarationEmitExpressionInExtends3.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 (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 __());
};
})();
exports.__esModule = true;
var ExportedClass = /** @class */ (function () {
function ExportedClass() {
}
return ExportedClass;
}());
exports.ExportedClass = ExportedClass;
var LocalClass = /** @class */ (function () {
function LocalClass() {
}
return LocalClass;
}());
function getLocalClass(c) {
return LocalClass;
}
function getExportedClass(c) {
return ExportedClass;
}
var MyClass = /** @class */ (function (_super) {
__extends(MyClass, _super);
function MyClass() {
return _super !== null && _super.apply(this, arguments) || this;
}
return MyClass;
}(getLocalClass(undefined)));
exports.MyClass = MyClass;
var MyClass2 = /** @class */ (function (_super) {
__extends(MyClass2, _super);
function MyClass2() {
return _super !== null && _super.apply(this, arguments) || this;
}
return MyClass2;
}(getExportedClass(undefined)));
exports.MyClass2 = MyClass2;
var MyClass3 = /** @class */ (function (_super) {
__extends(MyClass3, _super);
function MyClass3() {
return _super !== null && _super.apply(this, arguments) || this;
}
return MyClass3;
}(getExportedClass(undefined)));
exports.MyClass3 = MyClass3;
var MyClass4 = /** @class */ (function (_super) {
__extends(MyClass4, _super);
function MyClass4() {
return _super !== null && _super.apply(this, arguments) || this;
}
return MyClass4;
}(getExportedClass(undefined)));
exports.MyClass4 = MyClass4;
//// [declarationEmitExpressionInExtends3.d.ts]
export declare class ExportedClass<T> {
x: T;
}
declare class LocalClass<T, U> {
x: T;
y: U;
}
export interface ExportedInterface {
x: number;
}
interface LocalInterface {
x: number;
}
declare const MyClass_base: typeof LocalClass;
export declare class MyClass extends MyClass_base<string, number> {
}
declare const MyClass2_base: typeof ExportedClass;
export declare class MyClass2 extends MyClass2_base<string> {
}
declare const MyClass3_base: typeof ExportedClass;
export declare class MyClass3 extends MyClass3_base<LocalInterface> {
}
declare const MyClass4_base: typeof ExportedClass;
export declare class MyClass4 extends MyClass4_base<ExportedInterface> {
}
export {};
|
