Merge pull request #2805 from Microsoft/moduleFixes

Fix #2538 and #2801

Author: mhegazy

src/compiler/checker.ts

@@ -349,7 +349,8 @@ module ts {
                             }
                             result = undefined;
                         }
-                        else if (location.kind === SyntaxKind.SourceFile) {
+                        else if (location.kind === SyntaxKind.SourceFile ||
+                            (location.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>location).name.kind === SyntaxKind.StringLiteral)) {
                             result = getSymbol(getSymbolOfNode(location).exports, "default", meaning & SymbolFlags.ModuleMember);
                             let localSymbol = getLocalSymbolForExportDefault(result);
                             if (result && (result.flags & meaning) && localSymbol && localSymbol.name === name) {

src/compiler/emitter.ts

@@ -4621,19 +4621,6 @@ var __param = this.__param || function(index, decorator) { return function (targ
                 }
             }
 
-            function sortAMDModules(amdModules: {name: string; path: string}[]) {
-                // AMD modules with declared variable names go first
-                return amdModules.sort((moduleA, moduleB) => {
-                    if (moduleA.name === moduleB.name) {
-                        return 0;
-                    } else if (!moduleA.name) {
-                        return 1;
-                    } else {
-                        return -1;
-                    }
-                });
-            }
-
             function emitExportStarHelper() {
                 if (hasExportStars) {
                     writeLine();
@@ -4649,44 +4636,83 @@ var __param = this.__param || function(index, decorator) { return function (targ
 
             function emitAMDModule(node: SourceFile, startIndex: number) {
                 collectExternalModuleInfo(node);
-                writeLine();
-                write("define(");
-                sortAMDModules(node.amdDependencies);
-                if (node.amdModuleName) {
-                    write("\"" + node.amdModuleName + "\", ");
+                
+                // An AMD define function has the following shape:
+                //     define(id?, dependencies?, factory);
+                //
+                // This has the shape of
+                //     define(name, ["module1", "module2"], function (module1Alias) {
+                // The location of the alias in the parameter list in the factory function needs to 
+                // match the position of the module name in the dependency list.
+                //
+                // To ensure this is true in cases of modules with no aliases, e.g.: 
+                // `import "module"` or `<amd-dependency path= "a.css" />` 
+                // we need to add modules without alias names to the end of the dependencies list
+                
+                let aliasedModuleNames: string[] = [];   // names of modules with corresponding parameter in the 
+                                                         // factory function.
+                let unaliasedModuleNames: string[] = []; // names of modules with no corresponding parameters in
+                                                         // factory function.
+                let importAliasNames: string[] = [];     // names of the parameters in the factory function; these 
+                                                         // paramters need to match the indexes of the corresponding 
+                                                         // module names in aliasedModuleNames.
+
+                // Fill in amd-dependency tags
+                for (let amdDependency of node.amdDependencies) {
+                    if (amdDependency.name) {
+                        aliasedModuleNames.push("\"" + amdDependency.path + "\"");
+                        importAliasNames.push(amdDependency.name);
+                    }
+                    else {
+                        unaliasedModuleNames.push("\"" + amdDependency.path + "\"");
+                    }
                 }
-                write("[\"require\", \"exports\"");
+
                 for (let importNode of externalImports) {
-                    write(", ");
+                    // Find the name of the external module
+                    let externalModuleName = "";
                     let moduleName = getExternalModuleName(importNode);
                     if (moduleName.kind === SyntaxKind.StringLiteral) {
-                        emitLiteral(<LiteralExpression>moduleName);
+                        externalModuleName = getLiteralText(<LiteralExpression>moduleName);
+                    }
+
+                    // Find the name of the module alais, if there is one
+                    let importAliasName: string;
+                    let namespaceDeclaration = getNamespaceDeclarationNode(importNode);
+                    if (namespaceDeclaration && !isDefaultImport(importNode)) {
+                        importAliasName = getSourceTextOfNodeFromSourceFile(currentSourceFile, namespaceDeclaration.name);
+                    }
+                    else {
+                        importAliasName = getGeneratedNameForNode(<ImportDeclaration | ExportDeclaration>importNode);
+                    }
+
+                    if (importAliasName) {
+                        aliasedModuleNames.push(externalModuleName);
+                        importAliasNames.push(importAliasName);
                     }
                     else {
-                        write("\"\"");
+                        unaliasedModuleNames.push(externalModuleName);
                     }
                 }
-                for (let amdDependency of node.amdDependencies) {
-                    let text = "\"" + amdDependency.path + "\"";
+                
+                writeLine();
+                write("define(");
+                if (node.amdModuleName) {
+                    write("\"" + node.amdModuleName + "\", ");
+                }
+                write("[\"require\", \"exports\"");
+                if (aliasedModuleNames.length) {
                     write(", ");
-                    write(text);
+                    write(aliasedModuleNames.join(", "));
                 }
-                write("], function (require, exports");
-                for (let importNode of externalImports) {
+                if (unaliasedModuleNames.length) {
                     write(", ");
-                    let namespaceDeclaration = getNamespaceDeclarationNode(importNode);
-                    if (namespaceDeclaration && !isDefaultImport(importNode)) {
-                        emit(namespaceDeclaration.name);
-                    }
-                    else {
-                        write(getGeneratedNameForNode(<ImportDeclaration | ExportDeclaration>importNode));
-                    }
+                    write(unaliasedModuleNames.join(", "));
                 }
-                for (let amdDependency of node.amdDependencies) {
-                    if (amdDependency.name) {
-                        write(", ");
-                        write(amdDependency.name);
-                    }
+                write("], function (require, exports");
+                if (importAliasNames.length) {
+                    write(", ");
+                    write(importAliasNames.join(", "));
                 }
                 write(") {");
                 increaseIndent();

src/compiler/utilities.ts

@@ -1913,4 +1913,4 @@ module ts {
 
         return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), /*newLength:*/ newEndN - oldStartN);
     }
-}
+}

tests/baselines/reference/amdDependencyCommentName2.js

@@ -6,6 +6,6 @@ m1.f();
 
 //// [amdDependencyCommentName2.js]
 ///<amd-dependency path='bar' name='b'/>
-define(["require", "exports", "m2", "bar"], function (require, exports, m1, b) {
+define(["require", "exports", "bar", "m2"], function (require, exports, b, m1) {
     m1.f();
 });

tests/baselines/reference/amdDependencyCommentName3.js

@@ -10,6 +10,6 @@ m1.f();
 ///<amd-dependency path='bar' name='b'/>
 ///<amd-dependency path='foo'/>
 ///<amd-dependency path='goo' name='c'/>
-define(["require", "exports", "m2", "bar", "goo", "foo"], function (require, exports, m1, b, c) {
+define(["require", "exports", "bar", "goo", "m2", "foo"], function (require, exports, b, c, m1) {
     m1.f();
 });

tests/baselines/reference/amdDependencyCommentName4.errors.txt

@@ -0,0 +1,35 @@
+tests/cases/compiler/amdDependencyCommentName4.ts(8,21): error TS2307: Cannot find external module 'aliasedModule1'.
+tests/cases/compiler/amdDependencyCommentName4.ts(11,26): error TS2307: Cannot find external module 'aliasedModule2'.
+tests/cases/compiler/amdDependencyCommentName4.ts(14,15): error TS2307: Cannot find external module 'aliasedModule3'.
+tests/cases/compiler/amdDependencyCommentName4.ts(17,21): error TS2307: Cannot find external module 'aliasedModule4'.
+
+
+==== tests/cases/compiler/amdDependencyCommentName4.ts (4 errors) ====
+    ///<amd-dependency path='aliasedModule5' name='n1'/>
+    ///<amd-dependency path='unaliasedModule3'/>
+    ///<amd-dependency path='aliasedModule6' name='n2'/>
+    ///<amd-dependency path='unaliasedModule4'/>
+    
+    import "unaliasedModule1";
+    
+    import r1 = require("aliasedModule1");
+                        ~~~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'aliasedModule1'.
+    r1;
+    
+    import {p1, p2, p3} from "aliasedModule2";
+                             ~~~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'aliasedModule2'.
+    p1;
+    
+    import d from "aliasedModule3";
+                  ~~~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'aliasedModule3'.
+    d;
+    
+    import * as ns from "aliasedModule4";
+                        ~~~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'aliasedModule4'.
+    ns;
+    
+    import "unaliasedModule2";

tests/baselines/reference/amdDependencyCommentName4.js

@@ -0,0 +1,33 @@
+//// [amdDependencyCommentName4.ts]
+///<amd-dependency path='aliasedModule5' name='n1'/>
+///<amd-dependency path='unaliasedModule3'/>
+///<amd-dependency path='aliasedModule6' name='n2'/>
+///<amd-dependency path='unaliasedModule4'/>
+
+import "unaliasedModule1";
+
+import r1 = require("aliasedModule1");
+r1;
+
+import {p1, p2, p3} from "aliasedModule2";
+p1;
+
+import d from "aliasedModule3";
+d;
+
+import * as ns from "aliasedModule4";
+ns;
+
+import "unaliasedModule2";
+
+//// [amdDependencyCommentName4.js]
+///<amd-dependency path='aliasedModule5' name='n1'/>
+///<amd-dependency path='unaliasedModule3'/>
+///<amd-dependency path='aliasedModule6' name='n2'/>
+///<amd-dependency path='unaliasedModule4'/>
+define(["require", "exports", "aliasedModule5", "aliasedModule6", "aliasedModule1", "aliasedModule2", "aliasedModule3", "aliasedModule4", "unaliasedModule3", "unaliasedModule4", "unaliasedModule1", "unaliasedModule2"], function (require, exports, n1, n2, r1, aliasedModule2_1, aliasedModule3_1, ns) {
+    r1;
+    aliasedModule2_1.p1;
+    aliasedModule3_1.default;
+    ns;
+});

tests/baselines/reference/es5ExportDefaultClassDeclaration4.js

@@ -0,0 +1,28 @@
+//// [es5ExportDefaultClassDeclaration4.ts]
+
+declare module "foo" {
+    export var before: C;
+
+    export default class C {
+        method(): C;
+    }
+
+    export var after: C;
+
+    export var t: typeof C;
+}
+
+
+
+//// [es5ExportDefaultClassDeclaration4.js]
+
+
+//// [es5ExportDefaultClassDeclaration4.d.ts]
+declare module "foo" {
+    var before: C;
+    class C {
+        method(): C;
+    }
+    var after: C;
+    var t: typeof C;
+}

tests/baselines/reference/es5ExportDefaultClassDeclaration4.symbols

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/es5ExportDefaultClassDeclaration4.ts ===
+
+declare module "foo" {
+    export var before: C;
+>before : Symbol(before, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 14))
+>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25))
+
+    export default class C {
+>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25))
+
+        method(): C;
+>method : Symbol(method, Decl(es5ExportDefaultClassDeclaration4.ts, 4, 28))
+>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25))
+    }
+
+    export var after: C;
+>after : Symbol(after, Decl(es5ExportDefaultClassDeclaration4.ts, 8, 14))
+>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25))
+
+    export var t: typeof C;
+>t : Symbol(t, Decl(es5ExportDefaultClassDeclaration4.ts, 10, 14))
+>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25))
+}
+
+

tests/baselines/reference/es5ExportDefaultClassDeclaration4.types

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/es5ExportDefaultClassDeclaration4.ts ===
+
+declare module "foo" {
+    export var before: C;
+>before : C
+>C : C
+
+    export default class C {
+>C : C
+
+        method(): C;
+>method : () => C
+>C : C
+    }
+
+    export var after: C;
+>after : C
+>C : C
+
+    export var t: typeof C;
+>t : typeof C
+>C : typeof C
+}
+
+