Improvements to tsc --watch

Jakefile.js

@@ -91,6 +91,7 @@ var languageServiceLibrarySources = filesFromConfig(path.join(serverDirectory, "
 var harnessCoreSources = [
     "harness.ts",
     "virtualFileSystem.ts",
+    "virtualFileSystemWithWatch.ts",
     "sourceMapRecorder.ts",
     "harnessLanguageService.ts",
     "fourslash.ts",
@@ -128,6 +129,7 @@ var harnessSources = harnessCoreSources.concat([
     "convertCompilerOptionsFromJson.ts",
     "convertTypeAcquisitionFromJson.ts",
     "tsserverProjectSystem.ts",
+    "tscWatchMode.ts",
     "compileOnSave.ts",
     "typingsInstaller.ts",
     "projectErrors.ts",

src/compiler/checker.ts

@@ -1161,7 +1161,7 @@ namespace ts {
         }
 
         function diagnosticName(nameArg: __String | Identifier) {
-            return typeof nameArg === "string" ? unescapeLeadingUnderscores(nameArg as __String) : declarationNameToString(nameArg as Identifier);
+            return isString(nameArg) ? unescapeLeadingUnderscores(nameArg as __String) : declarationNameToString(nameArg as Identifier);
         }
 
         function isTypeParameterSymbolDeclaredInContainer(symbol: Symbol, container: Node) {

src/compiler/commandLineParser.ts

@@ -880,7 +880,7 @@ namespace ts {
      */
     export function readConfigFile(fileName: string, readFile: (path: string) => string | undefined): { config?: any; error?: Diagnostic } {
         const textOrDiagnostic = tryReadFile(fileName, readFile);
-        return typeof textOrDiagnostic === "string" ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
+        return isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
     }
 
     /**
@@ -902,7 +902,7 @@ namespace ts {
      */
     export function readJsonConfigFile(fileName: string, readFile: (path: string) => string | undefined): JsonSourceFile {
         const textOrDiagnostic = tryReadFile(fileName, readFile);
-        return typeof textOrDiagnostic === "string" ? parseJsonText(fileName, textOrDiagnostic) : <JsonSourceFile>{ parseDiagnostics: [textOrDiagnostic] };
+        return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : <JsonSourceFile>{ parseDiagnostics: [textOrDiagnostic] };
     }
 
     function tryReadFile(fileName: string, readFile: (path: string) => string | undefined): string | Diagnostic {
@@ -1106,9 +1106,9 @@ namespace ts {
                     if (!isDoubleQuotedString(valueExpression)) {
                         errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.String_literal_with_double_quotes_expected));
                     }
-                    reportInvalidOptionValue(option && (typeof option.type === "string" && option.type !== "string"));
+                    reportInvalidOptionValue(option && (isString(option.type) && option.type !== "string"));
                     const text = (<StringLiteral>valueExpression).text;
-                    if (option && typeof option.type !== "string") {
+                    if (option && !isString(option.type)) {
                         const customOption = <CommandLineOptionOfCustomType>option;
                         // Validate custom option type
                         if (!customOption.type.has(text)) {
@@ -1179,15 +1179,15 @@ namespace ts {
     function getCompilerOptionValueTypeString(option: CommandLineOption) {
         return option.type === "list" ?
             "Array" :
-            typeof option.type === "string" ? option.type : "string";
+            isString(option.type) ? option.type : "string";
     }
 
     function isCompilerOptionsValue(option: CommandLineOption, value: any): value is CompilerOptionsValue {
         if (option) {
             if (option.type === "list") {
                 return isArray(value);
             }
-            const expectedType = typeof option.type === "string" ? option.type : "string";
+            const expectedType = isString(option.type) ? option.type : "string";
             return typeof value === expectedType;
         }
     }
@@ -1571,7 +1571,7 @@ namespace ts {
         let extendedConfigPath: Path;
 
         if (json.extends) {
-            if (typeof json.extends !== "string") {
+            if (!isString(json.extends)) {
                 errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string"));
             }
             else {
@@ -1796,7 +1796,7 @@ namespace ts {
             if (optType === "list" && isArray(value)) {
                 return convertJsonOptionOfListType(<CommandLineOptionOfListType>opt, value, basePath, errors);
             }
-            else if (typeof optType !== "string") {
+            else if (!isString(optType)) {
                 return convertJsonOptionOfCustomType(<CommandLineOptionOfCustomType>opt, <string>value, errors);
             }
             return normalizeNonListOptionValue(opt, basePath, value);
@@ -1809,12 +1809,12 @@ namespace ts {
     function normalizeOptionValue(option: CommandLineOption, basePath: string, value: any): CompilerOptionsValue {
         if (option.type === "list") {
             const listOption = <CommandLineOptionOfListType>option;
-            if (listOption.element.isFilePath || typeof listOption.element.type !== "string") {
+            if (listOption.element.isFilePath || !isString(listOption.element.type)) {
                 return <CompilerOptionsValue>filter(map(value, v => normalizeOptionValue(listOption.element, basePath, v)), v => !!v);
             }
             return value;
         }
-        else if (typeof option.type !== "string") {
+        else if (!isString(option.type)) {
             return option.type.get(value);
         }
         return normalizeNonListOptionValue(option, basePath, value);
@@ -1979,7 +1979,7 @@ namespace ts {
      * @param host The host used to resolve files and directories.
      * @param errors An array for diagnostic reporting.
      */
-    export function getFileNamesFromConfigSpecs(spec: ConfigFileSpecs, basePath: string, options: CompilerOptions, host: ParseConfigHost, extraFileExtensions: ReadonlyArray<JsFileExtensionInfo>): ExpandResult {
+    export function getFileNamesFromConfigSpecs(spec: ConfigFileSpecs, basePath: string, options: CompilerOptions, host: ParseConfigHost, extraFileExtensions: ReadonlyArray<JsFileExtensionInfo> = []): ExpandResult {
         basePath = normalizePath(basePath);
 
         const keyMapper = host.useCaseSensitiveFileNames ? caseSensitiveKeyMapper : caseInsensitiveKeyMapper;

src/compiler/core.ts

@@ -473,12 +473,14 @@ namespace ts {
         return result;
     }
 
-    export function flatMapIter<T, U>(iter: Iterator<T>, mapfn: (x: T) => U | U[] | undefined): U[] {
-        const result: U[] = [];
+    export function flatMapIter<T>(iter: Iterator<T>): T[];
+    export function flatMapIter<T, U>(iter: Iterator<T>, mapfn: (x: T) => U | U[] | undefined): U[];
+    export function flatMapIter<T>(iter: Iterator<T>, mapfn?: (x: any) => any): any[] {
+        const result = [];
         while (true) {
             const { value, done } = iter.next();
             if (done) break;
-            const res = mapfn(value);
+            const res = mapfn ? mapfn(value) : value;
             if (res) {
                 if (isArray(res)) {
                     result.push(...res);
@@ -1201,6 +1203,13 @@ namespace ts {
         return Array.isArray ? Array.isArray(value) : value instanceof Array;
     }
 
+    /**
+     * Tests whether a value is string
+     */
+    export function isString(text: any): text is string {
+        return typeof text === "string";
+    }
+
     export function tryCast<TOut extends TIn, TIn = any>(value: TIn | undefined, test: (value: TIn) => value is TOut): TOut | undefined {
         return value !== undefined && test(value) ? value : undefined;
     }
@@ -1211,7 +1220,7 @@ namespace ts {
     }
 
     /** Does nothing. */
-    export function noop(): void {}
+    export function noop(): any {}
 
     /** Throws an error because a function is not implemented. */
     export function notImplemented(): never {
@@ -1454,16 +1463,16 @@ namespace ts {
     function compareMessageText(text1: string | DiagnosticMessageChain, text2: string | DiagnosticMessageChain): Comparison {
         while (text1 && text2) {
             // We still have both chains.
-            const string1 = typeof text1 === "string" ? text1 : text1.messageText;
-            const string2 = typeof text2 === "string" ? text2 : text2.messageText;
+            const string1 = isString(text1) ? text1 : text1.messageText;
+            const string2 = isString(text2) ? text2 : text2.messageText;
 
             const res = compareValues(string1, string2);
             if (res) {
                 return res;
             }
 
-            text1 = typeof text1 === "string" ? undefined : text1.next;
-            text2 = typeof text2 === "string" ? undefined : text2.next;
+            text1 = isString(text1) ? undefined : text1.next;
+            text2 = isString(text2) ? undefined : text2.next;
         }
 
         if (!text1 && !text2) {
@@ -2552,4 +2561,168 @@ namespace ts {
     export function isCheckJsEnabledForFile(sourceFile: SourceFile, compilerOptions: CompilerOptions) {
         return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
     }
+
+    export interface HostForCaching {
+        useCaseSensitiveFileNames: boolean;
+        writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
+        fileExists(path: string): boolean;
+        directoryExists(path: string): boolean;
+        createDirectory(path: string): void;
+        getCurrentDirectory(): string;
+        getDirectories(path: string): string[];
+        readDirectory(path: string, extensions?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<string>, depth?: number): string[];
+    }
+
+    export interface CachedHost {
+        writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
+        fileExists(path: string): boolean;
+        directoryExists(path: string): boolean;
+        createDirectory(path: string): void;
+        getCurrentDirectory(): string;
+        getDirectories(path: string): string[];
+        readDirectory(path: string, extensions?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<string>, depth?: number): string[];
+        addOrDeleteFileOrFolder(fileOrFolder: string): void;
+        clearCache(): void;
+    }
+
+    export function createCachedHost(host: HostForCaching): CachedHost {
+        const cachedReadDirectoryResult = createMap<FileSystemEntries>();
+        const getCurrentDirectory = memoize(() => host.getCurrentDirectory());
+        const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
+        return {
+            writeFile,
+            fileExists,
+            directoryExists,
+            createDirectory,
+            getCurrentDirectory,
+            getDirectories,
+            readDirectory,
+            addOrDeleteFileOrFolder,
+            clearCache
+        };
+
+        function toPath(fileName: string) {
+            return ts.toPath(fileName, getCurrentDirectory(), getCanonicalFileName);
+        }
+
+        function getFileSystemEntries(rootDir: string) {
+            const path = toPath(rootDir);
+            const cachedResult = cachedReadDirectoryResult.get(path);
+            if (cachedResult) {
+                return cachedResult;
+            }
+
+            const resultFromHost: FileSystemEntries = {
+                files: host.readDirectory(rootDir, /*extensions*/ undefined, /*exclude*/ undefined, /*include*/["*.*"]) || [],
+                directories: host.getDirectories(rootDir) || []
+            };
+
+            cachedReadDirectoryResult.set(path, resultFromHost);
+            return resultFromHost;
+        }
+
+        function canWorkWithCacheForDir(rootDir: string) {
+            // Some of the hosts might not be able to handle read directory or getDirectories
+            const path = toPath(rootDir);
+            if (cachedReadDirectoryResult.get(path)) {
+                return true;
+            }
+            try {
+                return getFileSystemEntries(rootDir);
+            }
+            catch (_e) {
+                return false;
+            }
+        }
+
+        function fileNameEqual(name1: string, name2: string) {
+            return getCanonicalFileName(name1) === getCanonicalFileName(name2);
+        }
+
+        function hasEntry(entries: ReadonlyArray<string>, name: string) {
+            return some(entries, file => fileNameEqual(file, name));
+        }
+
+        function updateFileSystemEntry(entries: ReadonlyArray<string>, baseName: string, isValid: boolean) {
+            if (hasEntry(entries, baseName)) {
+                if (!isValid) {
+                    return filter(entries, entry => !fileNameEqual(entry, baseName));
+                }
+            }
+            else if (isValid) {
+                return entries.concat(baseName);
+            }
+            return entries;
+        }
+
+        function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void {
+            const path = toPath(fileName);
+            const result = cachedReadDirectoryResult.get(getDirectoryPath(path));
+            const baseFileName = getBaseFileName(normalizePath(fileName));
+            if (result) {
+                result.files = updateFileSystemEntry(result.files, baseFileName, /*isValid*/ true);
+            }
+            return host.writeFile(fileName, data, writeByteOrderMark);
+        }
+
+        function fileExists(fileName: string): boolean {
+            const path = toPath(fileName);
+            const result = cachedReadDirectoryResult.get(getDirectoryPath(path));
+            const baseName = getBaseFileName(normalizePath(fileName));
+            return (result && hasEntry(result.files, baseName)) || host.fileExists(fileName);
+        }
+
+        function directoryExists(dirPath: string): boolean {
+            const path = toPath(dirPath);
+            return cachedReadDirectoryResult.has(path) || host.directoryExists(dirPath);
+        }
+
+        function createDirectory(dirPath: string) {
+            const path = toPath(dirPath);
+            const result = cachedReadDirectoryResult.get(getDirectoryPath(path));
+            const baseFileName = getBaseFileName(path);
+            if (result) {
+                result.directories = updateFileSystemEntry(result.directories, baseFileName, /*isValid*/ true);
+            }
+            host.createDirectory(dirPath);
+        }
+
+        function getDirectories(rootDir: string): string[] {
+            if (canWorkWithCacheForDir(rootDir)) {
+                return getFileSystemEntries(rootDir).directories.slice();
+            }
+            return host.getDirectories(rootDir);
+        }
+        function readDirectory(rootDir: string, extensions?: ReadonlyArray<string>, excludes?: ReadonlyArray<string>, includes?: ReadonlyArray<string>, depth?: number): string[] {
+            if (canWorkWithCacheForDir(rootDir)) {
+                return matchFiles(rootDir, extensions, excludes, includes, host.useCaseSensitiveFileNames, getCurrentDirectory(), depth, path => getFileSystemEntries(path));
+            }
+            return host.readDirectory(rootDir, extensions, excludes, includes, depth);
+        }
+
+        function addOrDeleteFileOrFolder(fileOrFolder: string) {
+            const path = toPath(fileOrFolder);
+            const existingResult = cachedReadDirectoryResult.get(path);
+            if (existingResult) {
+                if (!host.directoryExists(fileOrFolder)) {
+                    cachedReadDirectoryResult.delete(path);
+                }
+            }
+            else {
+                // Was this earlier file
+                const parentResult = cachedReadDirectoryResult.get(getDirectoryPath(path));
+                if (parentResult) {
+                    const baseName = getBaseFileName(fileOrFolder);
+                    if (parentResult) {
+                        parentResult.files = updateFileSystemEntry(parentResult.files, baseName, host.fileExists(path));
+                        parentResult.directories = updateFileSystemEntry(parentResult.directories, baseName, host.directoryExists(path));
+                    }
+                }
+            }
+        }
+
+        function clearCache() {
+            cachedReadDirectoryResult.clear();
+        }
+    }
 }

src/compiler/factory.ts

@@ -81,7 +81,7 @@ namespace ts {
         if (typeof value === "boolean") {
             return value ? createTrue() : createFalse();
         }
-        if (typeof value === "string") {
+        if (isString(value)) {
             return createStringLiteral(value);
         }
         return createLiteralFromNode(value);
@@ -2130,7 +2130,7 @@ namespace ts {
 
     export function createCatchClause(variableDeclaration: string | VariableDeclaration, block: Block) {
         const node = <CatchClause>createSynthesizedNode(SyntaxKind.CatchClause);
-        node.variableDeclaration = typeof variableDeclaration === "string" ? createVariableDeclaration(variableDeclaration) : variableDeclaration;
+        node.variableDeclaration = isString(variableDeclaration) ? createVariableDeclaration(variableDeclaration) : variableDeclaration;
         node.block = block;
         return node;
     }
@@ -2438,11 +2438,11 @@ namespace ts {
     function asName(name: string | EntityName): EntityName;
     function asName(name: string | Identifier | ThisTypeNode): Identifier | ThisTypeNode;
     function asName(name: string | Identifier | BindingName | PropertyName | QualifiedName | ThisTypeNode) {
-        return typeof name === "string" ? createIdentifier(name) : name;
+        return isString(name) ? createIdentifier(name) : name;
     }
 
     function asExpression(value: string | number | Expression) {
-        return typeof value === "string" || typeof value === "number" ? createLiteral(value) : value;
+        return isString(value) || typeof value === "number" ? createLiteral(value) : value;
     }
 
     function asNodeArray<T extends Node>(array: ReadonlyArray<T> | undefined): NodeArray<T> | undefined {