Add upper limit for the program size to prevent tsserver from crashing

src/compiler/commandLineParser.ts

@@ -407,6 +407,10 @@ namespace ts {
             },
             description: Diagnostics.Specify_library_files_to_be_included_in_the_compilation_Colon
         },
+        {
+            name: "disableProjectSizeLimit",
+            type: "boolean"
+        },
         {
             name: "strictNullChecks",
             type: "boolean",
@@ -723,10 +727,22 @@ namespace ts {
                 const supportedExtensions = getSupportedExtensions(options);
                 Debug.assert(indexOf(supportedExtensions, ".ts") < indexOf(supportedExtensions, ".d.ts"), "Changed priority of extensions to pick");
 
+                const potentialFiles: string[] = [];
+                if (host.readDirectoryWithMultipleExtensions) {
+                    addRange(potentialFiles, host.readDirectoryWithMultipleExtensions(basePath, supportedExtensions, exclude));
+                }
+                else {
+                    for (const extension of supportedExtensions) {
+                        addRange(potentialFiles, host.readDirectory(basePath, extension, exclude));
+                    }
+                }
                 // Get files of supported extensions in their order of resolution
                 for (const extension of supportedExtensions) {
-                    const filesInDirWithExtension = host.readDirectory(basePath, extension, exclude);
-                    for (const fileName of filesInDirWithExtension) {
+                    for (const fileName of potentialFiles) {
+                        if (!fileExtensionIs(fileName, extension)) {
+                            continue;
+                        }
+
                         // .ts extension would read the .d.ts extension files too but since .d.ts is lower priority extension,
                         // lets pick them when its turn comes up
                         if (extension === ".ts" && fileExtensionIs(fileName, ".d.ts")) {
@@ -746,8 +762,10 @@ namespace ts {
                             }
                         }
 
-                        filesSeen[fileName] = true;
-                        fileNames.push(fileName);
+                        if (!filesSeen[fileName]) {
+                            filesSeen[fileName] = true;
+                            fileNames.push(fileName);
+                        }
                     }
                 }
             }

src/compiler/program.ts

@@ -8,8 +8,6 @@ namespace ts {
     /* @internal */ export let ioReadTime = 0;
     /* @internal */ export let ioWriteTime = 0;
 
-    /** The version of the TypeScript compiler release */
-
     const emptyArray: any[] = [];
 
     const defaultLibrarySearchPaths = [
@@ -18,6 +16,7 @@ namespace ts {
         "node_modules/@types/",
     ];
 
+    /** The version of the TypeScript compiler release */
     export const version = "1.9.0";
 
     export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean): string {

src/compiler/sys.ts

@@ -15,6 +15,7 @@ namespace ts {
         useCaseSensitiveFileNames: boolean;
         write(s: string): void;
         readFile(path: string, encoding?: string): string;
+        getFileSize?(path: string): number;
         writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
         watchFile?(path: string, callback: FileWatcherCallback): FileWatcher;
         watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean): FileWatcher;
@@ -26,6 +27,7 @@ namespace ts {
         getCurrentDirectory(): string;
         getDirectories(path: string): string[];
         readDirectory(path: string, extension?: string, exclude?: string[]): string[];
+        readDirectoryWithMultipleExtensions?(path: string, extensions: string[], exclude?: string[]): string[];
         getModifiedTime?(path: string): Date;
         createHash?(data: string): string;
         getMemoryUsage?(): number;
@@ -79,7 +81,7 @@ namespace ts {
         realpath(path: string): string;
     };
 
-    export var sys: System = (function () {
+    export var sys: System = (function() {
 
         function getWScriptSystem(): System {
 
@@ -414,39 +416,64 @@ namespace ts {
                 return filter<string>(_fs.readdirSync(path), p => fileSystemEntryExists(combinePaths(path, p), FileSystemEntryKind.Directory));
             }
 
-            function readDirectory(path: string, extension?: string, exclude?: string[]): string[] {
-                const result: string[] = [];
-                exclude = map(exclude, s => getCanonicalPath(combinePaths(path, s)));
-                visitDirectory(path);
-                return result;
-                function visitDirectory(path: string) {
-                    const files = _fs.readdirSync(path || ".").sort();
-                    const directories: string[] = [];
-                    for (const current of files) {
+            function visitDirectory(path: string, result: string[], extension: string | string[], exclude: string[]) {
+                const files = _fs.readdirSync(path || ".").sort();
+                const directories: string[] = [];
+                for (const current of files) {
                         // This is necessary because on some file system node fails to exclude
                         // "." and "..". See https://github.com/nodejs/node/issues/4002
                         if (current === "." || current === "..") {
                             continue;
                         }
-                        const name = combinePaths(path, current);
-                        if (!contains(exclude, getCanonicalPath(name))) {
+                    const name = combinePaths(path, current);
+                    if (!contains(exclude, getCanonicalPath(name))) {
+                        // fs.statSync would throw an exception if the file is a symlink
+                        // whose linked file doesn't exist.
+                        try {
                             const stat = _fs.statSync(name);
                             if (stat.isFile()) {
-                                if (!extension || fileExtensionIs(name, extension)) {
+                                if (checkExtension(name)) {
                                     result.push(name);
                                 }
                             }
                             else if (stat.isDirectory()) {
                                 directories.push(name);
                             }
                         }
+                        catch (e) { }
                     }
-                    for (const current of directories) {
-                        visitDirectory(current);
+                }
+                for (const current of directories) {
+                    visitDirectory(current, result, extension, exclude);
+                }
+
+                function checkExtension(name: string) {
+                    if (!extension) {
+                        return true;
+                    }
+                    if (typeof extension === "string") {
+                        return fileExtensionIs(name, extension);
+                    }
+                    else {
+                        return forEach(extension, ext => fileExtensionIs(name, ext));
                     }
                 }
             }
 
+            function readDirectoryWithMultipleExtensions(path: string, extensions: string[], exclude?: string[]): string[] {
+                const result: string[] = [];
+                exclude = map(exclude, s => getCanonicalPath(combinePaths(path, s)));
+                visitDirectory(path, result, extensions, exclude);
+                return result;
+            }
+
+            function readDirectory(path: string, extension?: string, exclude?: string[]): string[] {
+                const result: string[] = [];
+                exclude = map(exclude, s => getCanonicalPath(combinePaths(path, s)));
+                visitDirectory(path, result, extension, exclude);
+                return result;
+            }
+
             return {
                 args: process.argv.slice(2),
                 newLine: _os.EOL,
@@ -503,7 +530,7 @@ namespace ts {
                         }
                     );
                 },
-                resolvePath: function (path: string): string {
+                resolvePath: function(path: string): string {
                     return _path.resolve(path);
                 },
                 fileExists,
@@ -521,6 +548,7 @@ namespace ts {
                 },
                 getDirectories,
                 readDirectory,
+                readDirectoryWithMultipleExtensions,
                 getModifiedTime(path) {
                     try {
                         return _fs.statSync(path).mtime;
@@ -540,6 +568,16 @@ namespace ts {
                     }
                     return process.memoryUsage().heapUsed;
                 },
+                getFileSize(path) {
+                    try {
+                        const stat = _fs.statSync(path);
+                        if (stat.isFile()) {
+                            return stat.size;
+                        }
+                    }
+                    catch (e) { }
+                    return 0;
+                },
                 exit(exitCode?: number): void {
                     process.exit(exitCode);
                 },

src/compiler/types.ts

@@ -1670,6 +1670,7 @@ namespace ts {
 
     export interface ParseConfigHost {
         readDirectory(rootDir: string, extension: string, exclude: string[]): string[];
+        readDirectoryWithMultipleExtensions?(rootDir: string, extensions: string[], exclude: string[]): string[];
     }
 
     export interface WriteFileCallback {
@@ -2561,6 +2562,7 @@ namespace ts {
         /* @internal */ suppressOutputPathCheck?: boolean;
         target?: ScriptTarget;
         traceResolution?: boolean;
+        disableSizeLimit?: boolean;
         types?: string[];
         /* @internal */ typesRoot?: string;
         typesSearchPaths?: string[];

src/compiler/utilities.ts

@@ -2695,6 +2695,10 @@ namespace ts {
         return forEach(supportedJavascriptExtensions, extension => fileExtensionIs(fileName, extension));
     }
 
+    export function hasTypeScriptFileExtension(fileName: string) {
+        return forEach(supportedTypeScriptExtensions, extension => fileExtensionIs(fileName, extension));
+    }
+
     /**
      * Replace each instance of non-ascii characters by one, two, three, or four escape sequences
      * representing the UTF-8 encoding of the character, and return the expanded char code list.