initial implementation of path mapping based module resolution

Author: vladima

src/compiler/commandLineParser.ts

@@ -250,10 +250,12 @@ namespace ts {
             name: "moduleResolution",
             type: {
                 "node": ModuleResolutionKind.NodeJs,
-                "classic": ModuleResolutionKind.Classic
+                "classic": ModuleResolutionKind.Classic,
+                // name is lowercased so we can still use hasProperty(userValue.toLower()) to check if user has entered the right value
+                "baseurl": ModuleResolutionKind.BaseUrl,
             },
             description: Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
-            error: Diagnostics.Argument_for_moduleResolution_option_must_be_node_or_classic,
+            error: Diagnostics.Argument_for_moduleResolution_option_must_be_node_classic_or_baseUrl,
         },
         {
             name: "allowUnusedLabels",
@@ -279,6 +281,26 @@ namespace ts {
             name: "forceConsistentCasingInFileNames",
             type: "boolean",
             description: Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
+        },
+        {
+            name: "baseUrl",
+            type: "string",
+            isFilePath: true,
+            description: Diagnostics.Base_directory_to_resolve_relative_module_names
+        },
+        {
+            // this option can only be specified in tsconfig.json
+            // use type = object to copy the value as-is
+            name: "paths",
+            type: "object",
+            isTSConfigOnly: true
+        },
+        {
+            // this option can only be specified in tsconfig.json
+            // use type = object to copy the value as-is
+            name: "rootDirs",
+            type: "object",
+            isTSConfigOnly: true
         }
     ];
 
@@ -339,31 +361,36 @@ namespace ts {
                     if (hasProperty(optionNameMap, s)) {
                         const opt = optionNameMap[s];
 
-                        // Check to see if no argument was provided (e.g. "--locale" is the last command-line argument).
-                        if (!args[i] && opt.type !== "boolean") {
-                            errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_expects_an_argument, opt.name));
+                        if (opt.isTSConfigOnly) {
+                            errors.push(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file, opt.name));
                         }
+                        else {
+                            // Check to see if no argument was provided (e.g. "--locale" is the last command-line argument).
+                            if (!args[i] && opt.type !== "boolean") {
+                                errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_expects_an_argument, opt.name));
+                            }
 
-                        switch (opt.type) {
-                            case "number":
-                                options[opt.name] = parseInt(args[i++]);
-                                break;
-                            case "boolean":
-                                options[opt.name] = true;
-                                break;
-                            case "string":
-                                options[opt.name] = args[i++] || "";
-                                break;
-                            // If not a primitive, the possible types are specified in what is effectively a map of options.
-                            default:
-                                let map = <Map<number>>opt.type;
-                                let key = (args[i++] || "").toLowerCase();
-                                if (hasProperty(map, key)) {
-                                    options[opt.name] = map[key];
-                                }
-                                else {
-                                    errors.push(createCompilerDiagnostic((<CommandLineOptionOfCustomType>opt).error));
-                                }
+                            switch (opt.type) {
+                                case "number":
+                                    options[opt.name] = parseInt(args[i++]);
+                                    break;
+                                case "boolean":
+                                    options[opt.name] = true;
+                                    break;
+                                case "string":
+                                    options[opt.name] = args[i++] || "";
+                                    break;
+                                // If not a primitive, the possible types are specified in what is effectively a map of options.
+                                default:
+                                    let map = <Map<number>>opt.type;
+                                    let key = (args[i++] || "").toLowerCase();
+                                    if (hasProperty(map, key)) {
+                                        options[opt.name] = map[key];
+                                    }
+                                    else {
+                                        errors.push(createCompilerDiagnostic((<CommandLineOptionOfCustomType>opt).error));
+                                    }
+                            }
                         }
                     }
                     else {
@@ -466,7 +493,6 @@ namespace ts {
         return output;
     }
 
-
     /**
       * Parse the contents of a config file (tsconfig.json).
       * @param json The contents of the config file to parse
@@ -477,6 +503,9 @@ namespace ts {
     export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string): ParsedCommandLine {
         const { options, errors } = convertCompilerOptionsFromJson(json["compilerOptions"], basePath);
 
+        // set basePath as inferredBaseUrl so baseUrl module resolution strategy can still work even if user have not specified baseUrl explicity
+        options.inferredBaseUrl = basePath;
+
         return {
             options,
             fileNames: getFileNames(),

src/compiler/diagnosticMessages.json

@@ -2060,7 +2060,26 @@
         "category": "Error",
         "code": 5054
     },
-
+    "Option '{0}' can only be used when option 'moduleResolution' is 'baseUrl'.": {
+        "category": "Error",
+        "code": 5055
+    },
+    "Pattern '{0}' can have at most one '*' character": {
+        "category": "Error",
+        "code": 5056
+    },
+    "Substitution '{0}' in pattern '{1}' in can have at most one '*' character": {
+        "category": "Error",
+        "code": 5057
+    },
+    "'moduleResolution' kind 'baseUrl' cannot be used without specifying '--baseUrl' option.": {
+        "category": "Error",
+        "code": 5058
+    },
+    "Module resolution kind cannot be determined automatically. Please specify module resolution explicitly via 'moduleResolution' option.": {
+        "category": "Error",
+        "code": 5059
+    },
     "Concatenate and emit output to single file.": {
         "category": "Message",
         "code": 6001
@@ -2253,10 +2272,14 @@
         "category": "Error",
         "code": 6062
     },
-    "Argument for '--moduleResolution' option must be 'node' or 'classic'.": {
+    "Argument for '--moduleResolution' option must be 'node', 'classic' or 'baseUrl'.": {
         "category": "Error",
         "code": 6063
     },
+    "Option '{0}' can only be specified in 'tsconfig.json' file.": {
+        "category": "Error",
+        "code": 6064
+    },
 
     "Enables experimental support for ES7 decorators.": {
         "category": "Message",
@@ -2322,6 +2345,10 @@
         "category": "Error",
         "code": 6082
     },
+    "Base directory to resolve relative module names.": {
+        "category": "Message",
+        "code": 6083
+    },    
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005