File: moduleAliasInterface.js

package info (click to toggle)
node-typescript 3.3.3333-1
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 324,548 kB
  • sloc: makefile: 6; sh: 3
file content (118 lines) | stat: -rw-r--r-- 2,582 bytes parent folder | download | duplicates (5)
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
//// [moduleAliasInterface.ts]
module _modes {
 export interface IMode {
  
 }
 
 export class Mode {
  
 }
}

// _modes. // produces an internal error - please implement in derived class

module editor {
 import modes = _modes;
 
 var i : modes.IMode;
  
 // If you just use p1:modes, the compiler accepts it - should be an error
 class Bug { 
  constructor(p1: modes.IMode, p2: modes.Mode) { }// should be an error on p2 - it's not exported
  public foo(p1:modes.IMode) {
   
  } 
 }
}

import modesOuter = _modes;
module editor2 {
 
 var i : modesOuter.IMode;
 
 class Bug {
     constructor(p1: modesOuter.IMode, p2: modesOuter.Mode) { }// no error here, since modesOuter is declared externally
  
 }
 
  module Foo { export class Bar{} }
 
  class Bug2 {
      constructor(p1: Foo.Bar, p2: modesOuter.Mode) { }
  }
}

module A1 {
    export interface A1I1 {}
    export class A1C1 {}
}

module B1 {
    import A1Alias1 = A1;
    
    var i : A1Alias1.A1I1;   
    var c : A1Alias1.A1C1;
}


//// [moduleAliasInterface.js]
var _modes;
(function (_modes) {
    var Mode = /** @class */ (function () {
        function Mode() {
        }
        return Mode;
    }());
    _modes.Mode = Mode;
})(_modes || (_modes = {}));
// _modes. // produces an internal error - please implement in derived class
var editor;
(function (editor) {
    var i;
    // If you just use p1:modes, the compiler accepts it - should be an error
    var Bug = /** @class */ (function () {
        function Bug(p1, p2) {
        } // should be an error on p2 - it's not exported
        Bug.prototype.foo = function (p1) {
        };
        return Bug;
    }());
})(editor || (editor = {}));
var modesOuter = _modes;
var editor2;
(function (editor2) {
    var i;
    var Bug = /** @class */ (function () {
        function Bug(p1, p2) {
        } // no error here, since modesOuter is declared externally
        return Bug;
    }());
    var Foo;
    (function (Foo) {
        var Bar = /** @class */ (function () {
            function Bar() {
            }
            return Bar;
        }());
        Foo.Bar = Bar;
    })(Foo || (Foo = {}));
    var Bug2 = /** @class */ (function () {
        function Bug2(p1, p2) {
        }
        return Bug2;
    }());
})(editor2 || (editor2 = {}));
var A1;
(function (A1) {
    var A1C1 = /** @class */ (function () {
        function A1C1() {
        }
        return A1C1;
    }());
    A1.A1C1 = A1C1;
})(A1 || (A1 = {}));
var B1;
(function (B1) {
    var i;
    var c;
})(B1 || (B1 = {}));