External module resolution

.gitattributes

@@ -1 +1,2 @@
-*.js linguist-language=TypeScript
+*.js linguist-language=TypeScript
+* -text

package.json

@@ -36,6 +36,9 @@
         "istanbul": "latest"
     },
     "scripts": {
-        "test": "jake runtests"
+        "test": "jake runtests",
+        "clean": "jake clean",
+        "build": "jake local",
+        "build-tests": "jake tests"
     }
 }

src/compiler/checker.ts

@@ -862,28 +862,19 @@ module ts {
             // Escape the name in the "require(...)" clause to ensure we find the right symbol.
             let moduleName = escapeIdentifier(moduleReferenceLiteral.text);
 
-            if (!moduleName) return;
+            if (!moduleName) {
+                return;
+            }
             let isRelative = isExternalModuleNameRelative(moduleName);
             if (!isRelative) {
                 let symbol = getSymbol(globals, '"' + moduleName + '"', SymbolFlags.ValueModule);
                 if (symbol) {
                     return symbol;
                 }
             }
-            let fileName: string;
-            let sourceFile: SourceFile;
-            while (true) {
-                fileName = normalizePath(combinePaths(searchPath, moduleName));
-                sourceFile = forEach(supportedExtensions, extension => host.getSourceFile(fileName + extension));
-                if (sourceFile || isRelative) {
-                    break;
-                }
-                let parentPath = getDirectoryPath(searchPath);
-                if (parentPath === searchPath) {
-                    break;
-                }
-                searchPath = parentPath;
-            }
+
+            let fileName = getResolvedModuleFileName(getSourceFile(location), moduleReferenceLiteral);
+            let sourceFile = fileName && host.getSourceFile(fileName);
             if (sourceFile) {
                 if (sourceFile.symbol) {
                     return sourceFile.symbol;

src/compiler/parser.ts

@@ -5678,7 +5678,8 @@ module ts {
             // will immediately bail out of walking any subtrees when we can see that their parents
             // are already correct.
             let result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /* setParentNode */ true)
-
+            // pass set of modules that were resolved before so 'createProgram' can reuse previous resolution results
+            result.resolvedModules = sourceFile.resolvedModules;
             return result;
         }
 

src/compiler/program.ts

@@ -422,54 +422,160 @@ module ts {
         }
 
         function processImportedModules(file: SourceFile, basePath: string) {
-            forEach(file.statements, node => {
-                if (node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration || node.kind === SyntaxKind.ExportDeclaration) {
-                    let moduleNameExpr = getExternalModuleName(node);
-                    if (moduleNameExpr && moduleNameExpr.kind === SyntaxKind.StringLiteral) {
+            let imports: LiteralExpression[];
+            forEach(file.statements, collectImports);
+            if (imports) {
+                ensureResolvedModuleNamesAreUptoDate(file, imports);
+                for (let importNode of imports) {
+                    resolveModule(importNode);
+                }
+            }
+            else {
+                file.resolvedModules = undefined;
+            }
+            return;
+
+            function findModuleSourceFile(fileName: string, nameLiteral: Expression) {
+                return findSourceFile(fileName, /* isDefaultLib */ false, file, nameLiteral.pos, nameLiteral.end - nameLiteral.pos);
+            }
+
+            function collectImports(node: Node): void  {
+                switch (node.kind) {
+                    case SyntaxKind.ImportDeclaration:
+                    case SyntaxKind.ImportEqualsDeclaration:
+                    case SyntaxKind.ExportDeclaration:
+                        let moduleNameExpr = getExternalModuleName(node);
+                        if (!moduleNameExpr || moduleNameExpr.kind !== SyntaxKind.StringLiteral) {
+                            return;
+                        }
                         let moduleNameText = (<LiteralExpression>moduleNameExpr).text;
-                        if (moduleNameText) {
-                            let searchPath = basePath;
-                            let searchName: string; 
-                            while (true) {
-                                searchName = normalizePath(combinePaths(searchPath, moduleNameText));
-                                if (forEach(supportedExtensions, extension => findModuleSourceFile(searchName + extension, moduleNameExpr))) {
-                                    break;
-                                }
-                                let parentPath = getDirectoryPath(searchPath);
-                                if (parentPath === searchPath) {
-                                    break;
+                        if (!moduleNameText) {
+                            return;
+                        }
+
+                        (imports || (imports = [])).push(<LiteralExpression>moduleNameExpr);
+                        break;
+                    case SyntaxKind.ModuleDeclaration:
+                        if ((<ModuleDeclaration>node).name.kind === SyntaxKind.StringLiteral && (node.flags & NodeFlags.Ambient || isDeclarationFile(file))) {
+                            // TypeScript 1.0 spec (April 2014): 12.1.6
+                            // An AmbientExternalModuleDeclaration declares an external module. 
+                            // This type of declaration is permitted only in the global module.
+                            // 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);
+                                    }
                                 }
-                                searchPath = parentPath;
-                            }
+                            });
                         }
+                        break;
+                }
+            }
+
+            function generateImportMap(relativeStartDirectory: string): Map<string> {
+                // find all of the map files between startDirectory and the project root directory
+                let foundMaps: Map<string>[] = [];
+                let currentDirectory = relativeStartDirectory;
+                while (true) {
+                    let map = tryGetImportMap(currentDirectory);
+                    if (map)
+                        foundMaps.push(map);
+                    // end of the line
+                    if (!currentDirectory)
+                        break;
+                    currentDirectory = getDirectoryPath(currentDirectory);
+                }
+
+                // merge all of the found maps, in reverse order, into the final map
+                let finalMap: Map<string> = {};
+                forEach(foundMaps.reverse(), foundMap => {
+                    for (let key in foundMap)
+                        finalMap[key] = foundMap[key];
+                });
+
+                return finalMap;
+            }
+
+            function tryGetImportMap(directory: string): Map<string> {
+                directory = normalizePath(directory);
+                let mapFilePath = normalizePath(combinePaths(directory, 'typescript-definition-map.json'));
+                let absoluteMapFilePath = combinePaths(host.getCurrentDirectory(), mapFilePath);
+                if (!sys.fileExists(absoluteMapFilePath))
+                    return null;
+
+                let map: Map<string> = JSON.parse(sys.readFile(absoluteMapFilePath));
+                let rootRelativeRoot: Map<string> = {};
+                for (let key in map) {
+                    rootRelativeRoot[key] = combinePaths(directory, map[key]);
+                }
+
+                return rootRelativeRoot;
+            }
+
+            function tryResolveImportFromMap(importMap: Map<string>, moduleNameExpr: LiteralExpression): string {
+                let seenKeys: Map<boolean> = {};
+                let currentName = moduleNameExpr.text;
+                while (true) {
+                    // cycle detection
+                    if (seenKeys[currentName])
+                        return null;
+                    seenKeys[currentName] = true;
+
+                    // follow the key in the map to an alias, file or nothing
+                    currentName = importMap[currentName];
+                    if (!currentName)
+                        // TODO: add file globbing support as fallback when exact match isn't found
+                        return null;
+
+                    // if we find a file then we are done
+                    //if (sys.fileExists(combinePaths(host.getCurrentDirectory(), currentName)))
+                    if (findModuleSourceFile(currentName, moduleNameExpr))
+                        return currentName;
+                }
+            }
+
+            function resolveModule(moduleNameExpr: LiteralExpression): void {
+                let searchPath = basePath;
+                let searchName: string;
+
+                if (hasResolvedModuleName(file, moduleNameExpr)) {
+                    let fileName = getResolvedModuleFileName(file, moduleNameExpr);
+                    if (fileName) {
+                        findModuleSourceFile(fileName, moduleNameExpr);
                     }
+                    return;
                 }
-                else if (node.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>node).name.kind === SyntaxKind.StringLiteral && (node.flags & NodeFlags.Ambient || isDeclarationFile(file))) {
-                    // TypeScript 1.0 spec (April 2014): 12.1.6
-                    // An AmbientExternalModuleDeclaration declares an external module. 
-                    // This type of declaration is permitted only in the global module.
-                    // 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 nameLiteral = <LiteralExpression>getExternalModuleImportEqualsDeclarationExpression(node);
-                            let moduleName = nameLiteral.text;
-                            if (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.
-                                let searchName = normalizePath(combinePaths(basePath, moduleName));
-                                forEach(supportedExtensions, extension => findModuleSourceFile(searchName + extension, nameLiteral));
-                            }
-                        }
-                    });
+
+                let importMap = generateImportMap(searchPath);
+                let importFromMap = tryResolveImportFromMap(importMap, moduleNameExpr);
+                if (importFromMap) {
+                    setResolvedModuleName(file, <LiteralExpression>moduleNameExpr, importFromMap);
+                    return;
                 }
-            });
 
-            function findModuleSourceFile(fileName: string, nameLiteral: Expression) {
-                return findSourceFile(fileName, /* isDefaultLib */ false, file, nameLiteral.pos, nameLiteral.end - nameLiteral.pos);
+                while (true) {
+                    searchName = normalizePath(combinePaths(searchPath, moduleNameExpr.text));
+                    let referencedSourceFile = forEach(supportedExtensions, extension => findModuleSourceFile(searchName + extension, moduleNameExpr));
+                    if (referencedSourceFile) {
+                        setResolvedModuleName(file, <LiteralExpression>moduleNameExpr, referencedSourceFile.fileName);
+                        return;
+                    }
+
+                    let parentPath = getDirectoryPath(searchPath);
+                    if (parentPath === searchPath) {
+                        break;
+                    }
+                    searchPath = parentPath;
+                }
+                // mark reference as non-resolved
+                setResolvedModuleName(file, <LiteralExpression>moduleNameExpr, undefined);
             }
         }
 

src/compiler/types.ts

@@ -1159,6 +1159,10 @@ module ts {
         // Stores a line map for the file.
         // This field should never be used directly to obtain line map, use getLineMap function instead.
         /* @internal */ lineMap: number[];
+
+        // Stores a mapping 'external module reference text' -> 'resolved file name' | undefined
+        // Content of this fiels should never be used directly - use getResolvedModuleFileName/setResolvedModuleFileName functions instead
+        /* @internal */ resolvedModules: Map<string>;
     }
 
     export interface ScriptReferenceHost {

src/compiler/utilities.ts

@@ -78,6 +78,30 @@ module ts {
         return node.end - node.pos;
     }
 
+    export function ensureResolvedModuleNamesAreUptoDate(sourceFile: SourceFile, imports: LiteralExpression[]): void {
+        if (!sourceFile.resolvedModules) {
+            return;
+        }
+        // TOOD: check that imports are consistent
+    }
+
+    export function hasResolvedModuleName(sourceFile: SourceFile, moduleReferenceLiteral: LiteralExpression): boolean {
+        return sourceFile.resolvedModules && hasProperty(sourceFile.resolvedModules, moduleReferenceLiteral.text);
+    }
+
+    export function getResolvedModuleFileName(sourceFile: SourceFile, moduleReferenceLiteral: LiteralExpression): string {
+        return sourceFile.resolvedModules && sourceFile.resolvedModules[moduleReferenceLiteral.text];
+    }
+
+    export function setResolvedModuleName(sourceFile: SourceFile, moduleReferenceLiteral: LiteralExpression, resolvedFileName: string): void {
+        if (!sourceFile.resolvedModules) {
+            sourceFile.resolvedModules = {};
+        }
+
+        // TODO: check if value for the given key already exists and if yes - that it is the same as new value
+        sourceFile.resolvedModules[moduleReferenceLiteral.text] = resolvedFileName;
+    }
+
     // Returns true if this node contains a parse error anywhere underneath it.
     export function containsParseError(node: Node): boolean {
         aggregateChildData(node);

src/services/services.ts

@@ -752,6 +752,7 @@ module ts {
         public languageVersion: ScriptTarget;
         public identifiers: Map<string>;
         public nameTable: Map<string>;
+        public resolvedModules: Map<string>;
 
         private namedDeclarations: Map<Declaration[]>;
 

tests/baselines/reference/project/import_via_mapping_file/amd/app/main.js

@@ -0,0 +1,3 @@
+define(["require", "exports", 'foo'], function (require, exports, foo_1) {
+    var foo = new foo_1.Foo();
+});

tests/baselines/reference/project/import_via_mapping_file/amd/import_via_mapping_file.json

@@ -0,0 +1,18 @@
+{
+    "scenario": "Import a module found in a mapping file",
+    "projectRoot": "tests/cases/projects/import_via_mapping_file",
+    "inputFiles": [
+        "app/main.ts"
+    ],
+    "resolvedInputFiles": [
+        "lib.d.ts",
+        "libs/library.ts",
+        "libs/library2.ts",
+        "app/main.ts"
+    ],
+    "emittedFiles": [
+        "libs/library.js",
+        "libs/library2.js",
+        "app/main.js"
+    ]
+}

tests/baselines/reference/project/import_via_mapping_file/amd/libs/library.js

@@ -0,0 +1,8 @@
+define(["require", "exports"], function (require, exports) {
+    var Foo = (function () {
+        function Foo() {
+        }
+        return Foo;
+    })();
+    exports.Foo = Foo;
+});

tests/baselines/reference/project/import_via_mapping_file/node/app/main.js

@@ -0,0 +1,2 @@
+var foo_1 = require('foo');
+var foo = new foo_1.Foo();

tests/baselines/reference/project/import_via_mapping_file/node/import_via_mapping_file.json

@@ -0,0 +1,18 @@
+{
+    "scenario": "Import a module found in a mapping file",
+    "projectRoot": "tests/cases/projects/import_via_mapping_file",
+    "inputFiles": [
+        "app/main.ts"
+    ],
+    "resolvedInputFiles": [
+        "lib.d.ts",
+        "libs/library.ts",
+        "libs/library2.ts",
+        "app/main.ts"
+    ],
+    "emittedFiles": [
+        "libs/library.js",
+        "libs/library2.js",
+        "app/main.js"
+    ]
+}

tests/baselines/reference/project/import_via_mapping_file/node/libs/library.js

@@ -0,0 +1,6 @@
+var Foo = (function () {
+    function Foo() {
+    }
+    return Foo;
+})();
+exports.Foo = Foo;

tests/cases/project/import_via_mapping_file.json

@@ -0,0 +1,7 @@
+{
+    "scenario": "Import a module found in a mapping file",
+    "projectRoot": "tests/cases/projects/import_via_mapping_file",
+    "inputFiles": [
+        "app/main.ts"
+    ]
+}

tests/cases/projects/import_via_mapping_file/app/main.ts

@@ -0,0 +1,5 @@
+import { Foo } from 'foo';
+import { Bar } from 'bar';
+
+let foo = new Foo();
+let bar = new Bar();

tests/cases/projects/import_via_mapping_file/app/typescript-definition-map.json

@@ -0,0 +1,3 @@
+{
+	"bar": "../libs/library2.ts"
+}

tests/cases/projects/import_via_mapping_file/libs/library.ts

@@ -0,0 +1,2 @@
+export class Foo {
+}

tests/cases/projects/import_via_mapping_file/libs/library2.ts

@@ -0,0 +1,2 @@
+export class Bar {
+}