A TSServer implementation that just uses the files list to avoid looking all over the file system.

Improves performance when running on a network file system.

Author: vikerman

src/server/g3ServerHostProxy.ts

@@ -0,0 +1,94 @@
+/// <reference path="./types.ts"/>
+
+namespace ts.server {
+    export function getG3ServerHostProxy(
+      projectName: string,
+      host: ServerHost,
+      logger: Logger): ServerHost {
+
+        let proxyHost:ServerHost = (<any>Object).assign({}, host);
+
+        // projectName is the tsconfig. Get the files list from there.
+        const {config, error} = readConfigFile(projectName, proxyHost.readFile);
+        if (!error) {
+            const projectDir = getDirectoryPath(projectName);
+
+            // Get the files list from the tsconfig.
+            let {options, errors, fileNames} = 
+                parseJsonConfigFileContent(config, proxyHost, projectDir);
+            if (!errors || errors.length === 0) {
+                // Get the list of files into a map. 
+                let fileMap: {[k: string]: boolean} = {};
+
+                // Just put the directory of the files in the known directories list.
+                // We don't rely on the behavior of walking up the directories to find
+                // the node_modules. (This part may not work for opensource)
+                let directoryMap: {[k: string]: boolean} = {};
+                let rootDirs = options.rootDirs;
+
+                // Add all the rootDirs to the known directories list.
+                options.rootDirs.forEach(d => {
+                    logger.info('Adding rootdir: ' + d);
+                    directoryMap[d] = true;
+                });
+
+                // For each file add to the filesMap and add their directory
+                // (and few directories above them) to the directoryMap. 
+                fileNames.forEach(f => {
+                    f = proxyHost.resolvePath(f);
+                    fileMap[f] = true;
+                    // TODO(viks): How deep should we go? Is 2 enough?
+                    for (let i = 0; i < 5; i++) {
+                        f = getDirectoryPath(f);
+                        logger.info('Adding dir: ' + getDirectoryPath(f));
+                        directoryMap[f] = true;
+                    }
+                });
+
+                // Override the fileExists in the ServerHost to reply using the fileMap
+                // instead of hitting the (network) file system.
+                proxyHost.fileExists = (path: string) => {
+                    path = proxyHost.resolvePath(path);
+                    if (path in fileMap) {
+                        // File found in map!
+                        logger.info('Found: ' + path);
+                        return true;
+                    } else {
+                        // Only ever allow looking in the filesystem for files inside
+                        // the project dir. Allows for discovery of new files
+                        // in the project without having to rebuild tsconfig.
+                        for (const rootDir of rootDirs) {
+                            if (path.indexOf(rootDir) === 0) {
+                                logger.info('Search: ' + path);
+                                return host.fileExists(path);
+                            }
+                        }
+                    }
+                    // File not in map. Just return false without hitting file system.
+                    logger.info('Did not find: ' + path);
+                    return false;
+                }
+
+                // Override the directoryExists in the ServerHost to reply using the
+                // directoryMap without hitting the file system.
+                proxyHost.directoryExists = (path: string) => {
+                    path = proxyHost.resolvePath(path);
+                    if (path in directoryMap) {
+                        logger.info('Dir Found: ' + path);
+                        return true;
+                    }
+                    // Allow looking around in the project directory.
+                    for (const rootDir of rootDirs) {
+                        if (path.indexOf(rootDir) === 0) {
+                            logger.info('Dir Search: ' + path);
+                            return host.directoryExists(path);
+                        }
+                    }
+                    logger.info('Dir NOT Found: ' + path);
+                    return false;
+                }
+            }
+        }
+        return proxyHost;
+    }
+}

src/server/project.ts

@@ -4,6 +4,7 @@
 /// <reference path="lsHost.ts"/>
 /// <reference path="typingsCache.ts"/>
 /// <reference path="builder.ts"/>
+/// <reference path="g3ServerHostProxy.ts"/>
 
 namespace ts.server {
 
@@ -202,7 +203,18 @@ namespace ts.server {
 
             this.setInternalCompilerOptionsForEmittingJsFiles();
 
-            this.lsHost = new LSHost(this.projectService.host, this, this.projectService.cancellationToken);
+            // Create a proxy server host that uses the files list to respond to
+            // fileExists and directoryExists so as to avoid going to the
+            // file system every time.
+            let host = this.projectService.host;
+            if (projectKind === ProjectKind.Configured && hasExplicitListOfFiles) {
+                host = getG3ServerHostProxy(
+                    projectName,
+                    this.projectService.host,
+                    this.projectService.logger);
+            }
+
+            this.lsHost = new LSHost(host, this, this.projectService.cancellationToken);
             this.lsHost.setCompilationSettings(this.compilerOptions);
 
             this.languageService = ts.createLanguageService(this.lsHost, this.documentRegistry);

src/server/tsconfig.json

@@ -17,6 +17,7 @@
         "scriptInfo.ts",
         "lsHost.ts",
         "typingsCache.ts",
+        "g3ServerHostProxy.ts",
         "project.ts",
         "editorServices.ts",
         "protocol.ts",