Merge branch 'master' into map5

Author: Andy Hanson

src/compiler/checker.ts

@@ -17278,7 +17278,7 @@ namespace ts {
             }
 
             if (node.kind === SyntaxKind.BindingElement) {
-                if (node.parent.kind === SyntaxKind.ObjectBindingPattern && languageVersion < ScriptTarget.ESNext) {
+                if (node.parent.kind === SyntaxKind.ObjectBindingPattern && languageVersion < ScriptTarget.ESNext && !isInAmbientContext(node)) {
                     checkExternalEmitHelpers(node, ExternalEmitHelpers.Rest);
                 }
                 // check computed properties inside property names of binding elements

src/compiler/diagnosticMessages.json

@@ -2757,7 +2757,7 @@
         "category": "Message",
         "code": 6094
     },
-    "Loading module as file / folder, candidate module location '{0}'.": {
+    "Loading module as file / folder, candidate module location '{0}', target file type '{1}'.": {
         "category": "Message",
         "code": 6095
     },
@@ -2769,7 +2769,7 @@
         "category": "Message",
         "code": 6097
     },
-    "Loading module '{0}' from 'node_modules' folder.": {
+    "Loading module '{0}' from 'node_modules' folder, target file type '{1}'.": {
         "category": "Message",
         "code": 6098
     },
@@ -2965,10 +2965,14 @@
         "category": "Message",
         "code": 6146
     },
-    "Resolution for module '{0}' was found in cache": {
+    "Resolution for module '{0}' was found in cache.": {
         "category": "Message",
         "code": 6147
     },
+    "Directory '{0}' does not exist, skipping all lookups in it.": {
+        "category": "Message",
+        "code": 6148
+    },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005

src/compiler/emitter.ts

@@ -670,8 +670,6 @@ namespace ts {
                 // Transformation nodes
                 case SyntaxKind.PartiallyEmittedExpression:
                     return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);
-                case SyntaxKind.RawExpression:
-                    return writeLines((<RawExpression>node).text);
             }
         }
 

src/compiler/factory.ts

@@ -1530,19 +1530,6 @@ namespace ts {
         return node;
     }
 
-    /**
-     * Creates a node that emits a string of raw text in an expression position. Raw text is never
-     * transformed, should be ES3 compliant, and should have the same precedence as
-     * PrimaryExpression.
-     *
-     * @param text The raw text of the node.
-     */
-    export function createRawExpression(text: string) {
-        const node = <RawExpression>createNode(SyntaxKind.RawExpression);
-        node.text = text;
-        return node;
-    }
-
     // Compound nodes
 
     export function createComma(left: Expression, right: Expression) {

src/compiler/moduleNameResolver.ts

@@ -32,7 +32,7 @@ namespace ts {
      * Kinds of file that we are currently looking for.
      * Typically there is one pass with Extensions.TypeScript, then a second pass with Extensions.JavaScript.
      */
-    const enum Extensions {
+    enum Extensions {
         TypeScript, /** '.ts', '.tsx', or '.d.ts' */
         JavaScript, /** '.js' or '.jsx' */
         DtsOnly /** Only '.d.ts' */
@@ -217,9 +217,13 @@ namespace ts {
                 return forEach(typeRoots, typeRoot => {
                     const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
                     const candidateDirectory = getDirectoryPath(candidate);
+                    const directoryExists = directoryProbablyExists(candidateDirectory, host);
+                    if (!directoryExists && traceEnabled) {
+                        trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);
+                    }
                     return resolvedTypeScriptOnly(
                         loadNodeModuleFromDirectory(Extensions.DtsOnly, candidate, failedLookupLocations,
-                            !directoryProbablyExists(candidateDirectory, host), moduleResolutionState));
+                            !directoryExists, moduleResolutionState));
                 });
             }
             else {
@@ -701,7 +705,7 @@ namespace ts {
 
             if (moduleHasNonRelativeName(moduleName)) {
                 if (traceEnabled) {
-                    trace(host, Diagnostics.Loading_module_0_from_node_modules_folder, moduleName);
+                    trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions]);
                 }
                 const resolved = loadModuleFromNodeModules(extensions, moduleName, containingDirectory, failedLookupLocations, state, cache);
                 // For node_modules lookups, get the real path so that multiple accesses to an `npm link`-ed module do not create duplicate files.
@@ -729,11 +733,33 @@ namespace ts {
 
     function nodeLoadModuleByRelativeName(extensions: Extensions, candidate: string, failedLookupLocations: Push<string>, onlyRecordFailures: boolean, state: ModuleResolutionState): Resolved | undefined {
         if (state.traceEnabled) {
-            trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0, candidate);
+            trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1, candidate, Extensions[extensions]);
         }
-
-        const resolvedFromFile = !pathEndsWithDirectorySeparator(candidate) && loadModuleFromFile(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
-        return resolvedFromFile || loadNodeModuleFromDirectory(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
+        if (!pathEndsWithDirectorySeparator(candidate)) {
+            if (!onlyRecordFailures) {
+                const parentOfCandidate = getDirectoryPath(candidate);
+                if (!directoryProbablyExists(parentOfCandidate, state.host)) {
+                    if (state.traceEnabled) {
+                        trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, parentOfCandidate);
+                    }
+                    onlyRecordFailures = true;
+                }
+            }
+            const resolvedFromFile = loadModuleFromFile(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
+            if (resolvedFromFile) {
+                return resolvedFromFile;
+            }
+        }
+        if (!onlyRecordFailures) {
+            const candidateExists = directoryProbablyExists(candidate, state.host);
+            if (!candidateExists) {
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidate);
+                }
+                onlyRecordFailures = true;
+            }
+        }
+        return loadNodeModuleFromDirectory(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
     }
 
     /* @internal */
@@ -792,19 +818,21 @@ namespace ts {
 
     /** Return the file if it exists. */
     function tryFile(fileName: string, failedLookupLocations: Push<string>, onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
-        if (!onlyRecordFailures && state.host.fileExists(fileName)) {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
+        if (!onlyRecordFailures) {
+            if (state.host.fileExists(fileName)) {
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
+                }
+                return fileName;
             }
-            return fileName;
-        }
-        else {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
+            else {
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
+                }
             }
-            failedLookupLocations.push(fileName);
-            return undefined;
         }
+        failedLookupLocations.push(fileName);
+        return undefined;
     }
 
     function loadNodeModuleFromDirectory(extensions: Extensions, candidate: string, failedLookupLocations: Push<string>, onlyRecordFailures: boolean, state: ModuleResolutionState): Resolved | undefined {
@@ -841,7 +869,7 @@ namespace ts {
             }
         }
         else {
-            if (state.traceEnabled) {
+            if (directoryExists && state.traceEnabled) {
                 trace(state.host, Diagnostics.File_0_does_not_exist, packageJsonPath);
             }
             // record package json as one of failed lookup locations - in the future if this file will appear it will invalidate resolution results
@@ -873,9 +901,7 @@ namespace ts {
         return combinePaths(directory, "package.json");
     }
 
-    function loadModuleFromNodeModulesFolder(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState): Resolved | undefined {
-        const nodeModulesFolder = combinePaths(directory, "node_modules");
-        const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
+    function loadModuleFromNodeModulesFolder(extensions: Extensions, moduleName: string, nodeModulesFolder: string, nodeModulesFolderExists: boolean, failedLookupLocations: Push<string>, state: ModuleResolutionState): Resolved | undefined {
         const candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));
 
         return loadModuleFromFile(extensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state) ||
@@ -905,12 +931,26 @@ namespace ts {
 
     /** Load a module from a single node_modules directory, but not from any ancestors' node_modules directories. */
     function loadModuleFromNodeModulesOneLevel(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState, typesOnly = false): Resolved | undefined {
-        const packageResult = typesOnly ? undefined : loadModuleFromNodeModulesFolder(extensions, moduleName, directory, failedLookupLocations, state);
+        const nodeModulesFolder = combinePaths(directory, "node_modules");
+        const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
+        if (!nodeModulesFolderExists && state.traceEnabled) {
+            trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder);
+        }
+
+        const packageResult = typesOnly ? undefined : loadModuleFromNodeModulesFolder(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, failedLookupLocations, state);
         if (packageResult) {
             return packageResult;
         }
         if (extensions !== Extensions.JavaScript) {
-            return loadModuleFromNodeModulesFolder(Extensions.DtsOnly, combinePaths("@types", moduleName), directory, failedLookupLocations, state);
+            const nodeModulesAtTypes = combinePaths(nodeModulesFolder, "@types");
+            let nodeModulesAtTypesExists = nodeModulesFolderExists;
+            if (nodeModulesFolderExists && !directoryProbablyExists(nodeModulesAtTypes, state.host)) {
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesAtTypes);
+                }
+                nodeModulesAtTypesExists = false;
+            }
+            return loadModuleFromNodeModulesFolder(Extensions.DtsOnly, moduleName, nodeModulesAtTypes, nodeModulesAtTypesExists, failedLookupLocations, state);
         }
     }