Merge pull request #5024 from Microsoft/importsInAmbientModules

collect imports and exports in ambient external modules

src/compiler/checker.ts

@@ -948,12 +948,6 @@ namespace ts {
             return symbol.flags & meaning ? symbol : resolveAlias(symbol);
         }
 
-        function isExternalModuleNameRelative(moduleName: string): boolean {
-            // TypeScript 1.0 spec (April 2014): 11.2.1
-            // An external module name is "relative" if the first term is "." or "..".
-            return moduleName.substr(0, 2) === "./" || moduleName.substr(0, 3) === "../" || moduleName.substr(0, 2) === ".\\" || moduleName.substr(0, 3) === "..\\";
-        }
-
         function resolveExternalModuleName(location: Node, moduleReferenceExpression: Expression): Symbol {
             if (moduleReferenceExpression.kind !== SyntaxKind.StringLiteral) {
                 return;

src/compiler/program.ts

@@ -692,6 +692,12 @@ namespace ts {
             
             let imports: LiteralExpression[];
             for (let node of file.statements) {
+                collect(node, /* allowRelativeModuleNames */ true);
+            }
+
+            file.imports = imports || emptyArray;
+            
+            function collect(node: Node, allowRelativeModuleNames: boolean): void {
                 switch (node.kind) {
                     case SyntaxKind.ImportDeclaration:
                     case SyntaxKind.ImportEqualsDeclaration:
@@ -704,7 +710,9 @@ namespace ts {
                             break;
                         }
 
-                        (imports || (imports = [])).push(<LiteralExpression>moduleNameExpr);
+                        if (allowRelativeModuleNames || !isExternalModuleNameRelative((<LiteralExpression>moduleNameExpr).text)) {
+                            (imports || (imports = [])).push(<LiteralExpression>moduleNameExpr);
+                        }
                         break;
                     case SyntaxKind.ModuleDeclaration:
                         if ((<ModuleDeclaration>node).name.kind === SyntaxKind.StringLiteral && (node.flags & NodeFlags.Ambient || isDeclarationFile(file))) {
@@ -714,23 +722,15 @@ namespace ts {
                             // The StringLiteral must specify a top - level external module name.
                             // Relative external module names are not permitted
                             forEachChild((<ModuleDeclaration>node).body, node => {
-                                if (isExternalModuleImportEqualsDeclaration(node) &&
-                                    getExternalModuleImportEqualsDeclarationExpression(node).kind === SyntaxKind.StringLiteral) {
-                                    let moduleName = <LiteralExpression>getExternalModuleImportEqualsDeclarationExpression(node);
-                                    // TypeScript 1.0 spec (April 2014): 12.1.6
-                                    // An ExternalImportDeclaration in anAmbientExternalModuleDeclaration may reference other external modules 
-                                    // only through top - level external module names. Relative external module names are not permitted.
-                                    if (moduleName) {
-                                        (imports || (imports = [])).push(moduleName);
-                                    }
-                                }
+                                // TypeScript 1.0 spec (April 2014): 12.1.6
+                                // An ExternalImportDeclaration in anAmbientExternalModuleDeclaration may reference other external modules 
+                                // only through top - level external module names. Relative external module names are not permitted.
+                                collect(node, /* allowRelativeModuleNames */ false);
                             });
                         }
                         break;
                 }
             }
-
-            file.imports = imports || emptyArray;
         }
 
         function processSourceFile(fileName: string, isDefaultLib: boolean, refFile?: SourceFile, refPos?: number, refEnd?: number) {

src/compiler/utilities.ts

@@ -992,6 +992,12 @@ namespace ts {
         }
         return false;
     }
+    
+    export function isExternalModuleNameRelative(moduleName: string): boolean {
+        // TypeScript 1.0 spec (April 2014): 11.2.1
+        // An external module name is "relative" if the first term is "." or "..".
+        return moduleName.substr(0, 2) === "./" || moduleName.substr(0, 3) === "../" || moduleName.substr(0, 2) === ".\\" || moduleName.substr(0, 3) === "..\\";
+    }
 
     export function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean) {
         let moduleState = getModuleInstanceState(node);

tests/baselines/reference/exportsInAmbientModules1.js

@@ -0,0 +1,13 @@
+//// [tests/cases/compiler/exportsInAmbientModules1.ts] ////
+
+//// [external.d.ts]
+
+export var x: number
+
+//// [main.ts]
+
+declare module "M" {
+    export {x} from "external"
+}
+
+//// [main.js]

tests/baselines/reference/exportsInAmbientModules1.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/external.d.ts ===
+
+export var x: number
+>x : Symbol(x, Decl(external.d.ts, 1, 10))
+
+=== tests/cases/compiler/main.ts ===
+
+declare module "M" {
+    export {x} from "external"
+>x : Symbol(x, Decl(main.ts, 2, 12))
+}

tests/baselines/reference/exportsInAmbientModules1.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/external.d.ts ===
+
+export var x: number
+>x : number
+
+=== tests/cases/compiler/main.ts ===
+
+declare module "M" {
+    export {x} from "external"
+>x : number
+}

tests/baselines/reference/exportsInAmbientModules2.js

@@ -0,0 +1,13 @@
+//// [tests/cases/compiler/exportsInAmbientModules2.ts] ////
+
+//// [external.d.ts]
+
+export default class C {}
+
+//// [main.ts]
+
+declare module "M" {
+    export * from "external"
+}
+
+//// [main.js]

tests/baselines/reference/exportsInAmbientModules2.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/external.d.ts ===
+
+export default class C {}
+>C : Symbol(C, Decl(external.d.ts, 0, 0))
+
+=== tests/cases/compiler/main.ts ===
+
+No type information for this code.declare module "M" {
+No type information for this code.    export * from "external"
+No type information for this code.}
+No type information for this code.

tests/baselines/reference/exportsInAmbientModules2.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/external.d.ts ===
+
+export default class C {}
+>C : C
+
+=== tests/cases/compiler/main.ts ===
+
+No type information for this code.declare module "M" {
+No type information for this code.    export * from "external"
+No type information for this code.}
+No type information for this code.

tests/baselines/reference/importsInAmbientModules1.js

@@ -0,0 +1,13 @@
+//// [tests/cases/compiler/importsInAmbientModules1.ts] ////
+
+//// [external.d.ts]
+
+export var x: number
+
+//// [main.ts]
+
+declare module "M" {
+    import {x} from "external"
+}
+
+//// [main.js]

tests/baselines/reference/importsInAmbientModules1.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/external.d.ts ===
+
+export var x: number
+>x : Symbol(x, Decl(external.d.ts, 1, 10))
+
+=== tests/cases/compiler/main.ts ===
+
+declare module "M" {
+    import {x} from "external"
+>x : Symbol(x, Decl(main.ts, 2, 12))
+}

tests/baselines/reference/importsInAmbientModules1.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/external.d.ts ===
+
+export var x: number
+>x : number
+
+=== tests/cases/compiler/main.ts ===
+
+declare module "M" {
+    import {x} from "external"
+>x : number
+}

tests/baselines/reference/importsInAmbientModules2.js

@@ -0,0 +1,13 @@
+//// [tests/cases/compiler/importsInAmbientModules2.ts] ////
+
+//// [external.d.ts]
+
+export default class C {}
+
+//// [main.ts]
+
+declare module "M" {
+    import C from "external"
+}
+
+//// [main.js]

tests/baselines/reference/importsInAmbientModules2.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/external.d.ts ===
+
+export default class C {}
+>C : Symbol(C, Decl(external.d.ts, 0, 0))
+
+=== tests/cases/compiler/main.ts ===
+
+declare module "M" {
+    import C from "external"
+>C : Symbol(C, Decl(main.ts, 2, 10))
+}

tests/baselines/reference/importsInAmbientModules2.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/external.d.ts ===
+
+export default class C {}
+>C : C
+
+=== tests/cases/compiler/main.ts ===
+
+declare module "M" {
+    import C from "external"
+>C : typeof C
+}

tests/baselines/reference/importsInAmbientModules3.js

@@ -0,0 +1,13 @@
+//// [tests/cases/compiler/importsInAmbientModules3.ts] ////
+
+//// [external.d.ts]
+
+export default class C {}
+
+//// [main.ts]
+
+declare module "M" {
+    import C = require("external");
+}
+
+//// [main.js]

tests/baselines/reference/importsInAmbientModules3.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/main.ts ===
+
+declare module "M" {
+    import C = require("external");
+>C : Symbol(C, Decl(main.ts, 1, 20))
+}
+=== tests/cases/compiler/external.d.ts ===
+
+export default class C {}
+>C : Symbol(C, Decl(external.d.ts, 0, 0))
+

tests/baselines/reference/importsInAmbientModules3.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/main.ts ===
+
+declare module "M" {
+    import C = require("external");
+>C : typeof C
+}
+=== tests/cases/compiler/external.d.ts ===
+
+export default class C {}
+>C : C
+

tests/cases/compiler/exportsInAmbientModules1.ts

@@ -0,0 +1,10 @@
+// @module: amd
+
+// @filename: external.d.ts
+export var x: number
+
+// @filename: main.ts
+
+declare module "M" {
+    export {x} from "external"
+}

tests/cases/compiler/exportsInAmbientModules2.ts

@@ -0,0 +1,10 @@
+// @module: amd
+
+// @filename: external.d.ts
+export default class C {}
+
+// @filename: main.ts
+
+declare module "M" {
+    export * from "external"
+}

tests/cases/compiler/importsInAmbientModules1.ts

@@ -0,0 +1,10 @@
+// @module: amd
+
+// @filename: external.d.ts
+export var x: number
+
+// @filename: main.ts
+
+declare module "M" {
+    import {x} from "external"
+}

tests/cases/compiler/importsInAmbientModules2.ts

@@ -0,0 +1,10 @@
+// @module: amd
+
+// @filename: external.d.ts
+export default class C {}
+
+// @filename: main.ts
+
+declare module "M" {
+    import C from "external"
+}

tests/cases/compiler/importsInAmbientModules3.ts

@@ -0,0 +1,10 @@
+// @module: amd
+
+// @filename: external.d.ts
+export default class C {}
+
+// @filename: main.ts
+
+declare module "M" {
+    import C = require("external");
+}