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
|
//// [moduleVisibilityTest2.ts]
module OuterMod {
export function someExportedOuterFunc() { return -1; }
export module OuterInnerMod {
export function someExportedOuterInnerFunc() { return "foo"; }
}
}
import OuterInnerAlias = OuterMod.OuterInnerMod;
module M {
module InnerMod {
export function someExportedInnerFunc() { return -2; }
}
enum E {
A,
B,
C,
}
var x = 5;
export declare var exported_var;
var y = x + x;
interface I {
someMethod():number;
}
class B {public b = 0;}
export class C implements I {
public someMethodThatCallsAnOuterMethod() {return OuterInnerAlias.someExportedOuterInnerFunc();}
public someMethodThatCallsAnInnerMethod() {return InnerMod.someExportedInnerFunc();}
public someMethodThatCallsAnOuterInnerMethod() {return OuterMod.someExportedOuterFunc();}
public someMethod() { return 0; }
public someProp = 1;
constructor() {
function someInnerFunc() { return 2; }
var someInnerVar = 3;
}
}
var someModuleVar = 4;
function someModuleFunction() { return 5;}
}
module M {
export var c = x;
export var meb = M.E.B;
}
var cprime : M.I = <M.I>null;
var c = new M.C();
var z = M.x;
var alpha = M.E.A;
var omega = M.exported_var;
c.someMethodThatCallsAnOuterMethod();
//// [moduleVisibilityTest2.js]
var OuterMod;
(function (OuterMod) {
function someExportedOuterFunc() { return -1; }
OuterMod.someExportedOuterFunc = someExportedOuterFunc;
var OuterInnerMod;
(function (OuterInnerMod) {
function someExportedOuterInnerFunc() { return "foo"; }
OuterInnerMod.someExportedOuterInnerFunc = someExportedOuterInnerFunc;
})(OuterInnerMod = OuterMod.OuterInnerMod || (OuterMod.OuterInnerMod = {}));
})(OuterMod || (OuterMod = {}));
var OuterInnerAlias = OuterMod.OuterInnerMod;
var M;
(function (M) {
var InnerMod;
(function (InnerMod) {
function someExportedInnerFunc() { return -2; }
InnerMod.someExportedInnerFunc = someExportedInnerFunc;
})(InnerMod || (InnerMod = {}));
var E;
(function (E) {
E[E["A"] = 0] = "A";
E[E["B"] = 1] = "B";
E[E["C"] = 2] = "C";
})(E || (E = {}));
var x = 5;
var y = x + x;
var B = /** @class */ (function () {
function B() {
this.b = 0;
}
return B;
}());
var C = /** @class */ (function () {
function C() {
this.someProp = 1;
function someInnerFunc() { return 2; }
var someInnerVar = 3;
}
C.prototype.someMethodThatCallsAnOuterMethod = function () { return OuterInnerAlias.someExportedOuterInnerFunc(); };
C.prototype.someMethodThatCallsAnInnerMethod = function () { return InnerMod.someExportedInnerFunc(); };
C.prototype.someMethodThatCallsAnOuterInnerMethod = function () { return OuterMod.someExportedOuterFunc(); };
C.prototype.someMethod = function () { return 0; };
return C;
}());
M.C = C;
var someModuleVar = 4;
function someModuleFunction() { return 5; }
})(M || (M = {}));
(function (M) {
M.c = x;
M.meb = M.E.B;
})(M || (M = {}));
var cprime = null;
var c = new M.C();
var z = M.x;
var alpha = M.E.A;
var omega = M.exported_var;
c.someMethodThatCallsAnOuterMethod();
|
