diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 227372ce30d..8ceccc0e880 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -29,18 +29,18 @@ namespace ts {
         return undefined;
     }
     
-    export function getDefaultModuleNameResolver(options: CompilerOptions): ModuleNameResolver {
-        // TODO: return different resolver based on compiler options (i.e. module kind)
-        return resolveModuleName;
-    }
-    
     export function resolveTripleslashReference(moduleName: string, containingFile: string): string {
         let basePath = getDirectoryPath(containingFile);
         let referencedFileName = isRootedDiskPath(moduleName) ? moduleName : combinePaths(basePath, moduleName);
         return normalizePath(referencedFileName);
     }
+    
+    export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModule {
+        // TODO: use different resolution strategy based on compiler options
+        return legacyNameResolver(moduleName, containingFile, compilerOptions, host);
+    }
 
-    function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModule {
+    function legacyNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModule {
         
         // module names that contain '!' are used to reference resources and are not resolved to actual files on disk
         if (moduleName.indexOf('!') != -1) {
@@ -226,10 +226,9 @@ namespace ts {
         if (!options.noResolve) {
             resolveModuleNamesWorker = host.resolveModuleNames;
             if (!resolveModuleNamesWorker) {
-                let defaultResolver = getDefaultModuleNameResolver(options);
                 resolveModuleNamesWorker = (moduleNames, containingFile) => {
                     return map(moduleNames, moduleName => {
-                        let moduleResolution = defaultResolver(moduleName, containingFile, options, host);
+                        let moduleResolution = resolveModuleName(moduleName, containingFile, options, host);
                         return moduleResolution.resolvedFileName;
                     });
                 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 1bac2917e8a..d709e11d4e3 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2244,6 +2244,8 @@ namespace ts {
     
     export interface ModuleResolutionHost {
         fileExists(fileName: string): boolean;
+        // readFile function is used to read arbitrary text files on disk, i.e. when resolution procedure needs the content of 'package.json'
+        // to determine location of bundled typings for node module 
         readFile(fileName: string): string;
     }
     
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 578c9cce553..82621db291a 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -106,7 +106,6 @@ namespace ts.server {
             let resolvedFileNames: string[] = [];
             
             let compilerOptions = this.getCompilationSettings();
-            let defaultResolver = ts.getDefaultModuleNameResolver(compilerOptions);
                         
             for (let moduleName of moduleNames) {
                 // check if this is a duplicate entry in the list
@@ -118,7 +117,7 @@ namespace ts.server {
                         resolution = existingResolution;
                     }
                     else {
-                        resolution = <TimestampedResolvedModule>defaultResolver(moduleName, containingFile, compilerOptions, this.moduleResolutionHost);
+                        resolution = <TimestampedResolvedModule>resolveModuleName(moduleName, containingFile, compilerOptions, this.moduleResolutionHost);
                         resolution.lastCheckTime = Date.now();
                         newResolutions[moduleName] = resolution;                                                
                     }
diff --git a/src/services/services.ts b/src/services/services.ts
index a3b31afabf0..c01b7316a81 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1837,7 +1837,7 @@ namespace ts {
             getCanonicalFileName: fileName => fileName,
             getCurrentDirectory: () => "",
             getNewLine: () => newLine,
-
+            // these two methods should never be called in transpile scenarios since 'noResolve' is set to 'true'
             fileExists: (fileName): boolean => { throw new Error("Should never be called."); },
             readFile: (fileName): string => { throw new Error("Should never be called."); }
         };
@@ -2057,11 +2057,6 @@ namespace ts {
         };
     }
 
-    export function resolveModuleName(fileName: string, moduleName: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModule {
-        let resolver = getDefaultModuleNameResolver(compilerOptions);
-        return resolver(moduleName, fileName, compilerOptions, host);
-    }
-
     export function preProcessFile(sourceText: string, readImportFiles = true): PreProcessedFileInfo {
         let referencedFiles: FileReference[] = [];
         let importedFiles: FileReference[] = [];
@@ -2578,21 +2573,21 @@ namespace ts {
                 getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
                 writeFile: (fileName, data, writeByteOrderMark) => { },
                 getCurrentDirectory: () => host.getCurrentDirectory(),
-                fileExists: (fileName): boolean => { throw new Error("Not implemented"); },
-                readFile: (fileName): string => { throw new Error("Not implemented"); }
+                fileExists: (fileName): boolean => { 
+                    // stub missing host functionality
+                    Debug.assert(!host.resolveModuleNames);
+                    return hostCache.getOrCreateEntry(fileName) !== undefined; 
+                },
+                readFile: (fileName): string => {
+                    // stub missing host functionality
+                    let entry = hostCache.getOrCreateEntry(fileName);
+                    return entry && entry.scriptSnapshot.getText(0, entry.scriptSnapshot.getLength());
+                }
             };
 
             if (host.resolveModuleNames) {
                 compilerHost.resolveModuleNames = (moduleNames, containingFile) => host.resolveModuleNames(moduleNames, containingFile)
             }
-            else {
-                // stub missing host functionality
-                compilerHost.fileExists = fileName => hostCache.getOrCreateEntry(fileName) !== undefined;
-                compilerHost.readFile = fileName => {
-                    let entry = hostCache.getOrCreateEntry(fileName);
-                    return entry && entry.scriptSnapshot.getText(0, entry.scriptSnapshot.getLength());
-                }
-            }
 
             let newProgram = createProgram(hostCache.getRootFileNames(), newSettings, compilerHost, program);