Instead of using system as object on WatchHost, create WatchCompilerHost that combines the functionality

sheetalkamat · sheetalkamat · commit 944f8b879288 · 2017-12-05T11:46:45.000-08:00
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -3023,9 +3023,7 @@ namespace ts {
         const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
         return {
             useCaseSensitiveFileNames: host.useCaseSensitiveFileNames,
-            newLine: host.newLine,
             readFile: (path, encoding) => host.readFile(path, encoding),
-            write: s => host.write(s),
             writeFile,
             fileExists,
             directoryExists,
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
@@ -34,9 +34,7 @@ namespace ts {
      * Partial interface of the System thats needed to support the caching of directory structure
      */
     export interface DirectoryStructureHost {
-        newLine: string;
         useCaseSensitiveFileNames: boolean;
-        write(s: string): void;
         readFile(path: string, encoding?: string): string | undefined;
         writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
         fileExists(path: string): boolean;
@@ -49,7 +47,9 @@ namespace ts {
     }
 
     export interface System extends DirectoryStructureHost {
+        newLine: string;
         args: string[];
+        write(s: string): void;
         getFileSize?(path: string): number;
         /**
          * @pollingInterval - this parameter is used in polling-based watchers and ignored in watchers that
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
@@ -150,37 +150,34 @@ namespace ts {
         return sys.exit(exitStatus);
     }
 
-    function createProgramCompilerWithBuilderState() {
-        const compilerWithBuilderState = ts.createProgramCompilerWithBuilderState(sys, reportDiagnostic);
-        return (host: DirectoryStructureHost, program: Program) => {
+    function createWatchCompilerHost(): WatchCompilerHost {
+        const watchCompilerHost = ts.createWatchCompilerHost(sys, reportDiagnostic);
+        const compilerWithBuilderState = watchCompilerHost.afterProgramCreate;
+        watchCompilerHost.beforeProgramCreate = enableStatistics;
+        watchCompilerHost.afterProgramCreate = (host, program) => {
             compilerWithBuilderState(host, program);
             reportStatistics(program);
         };
+        return watchCompilerHost;
     }
 
     function createWatchOfConfigFile(configParseResult: ParsedCommandLine, optionsToExtend: CompilerOptions) {
-        createWatch({
-            system: sys,
-            beforeProgramCreate: enableStatistics,
-            afterProgramCreate: createProgramCompilerWithBuilderState(),
-            onConfigFileDiagnostic: reportDiagnostic,
-            rootFiles: configParseResult.fileNames,
-            options: configParseResult.options,
-            configFileName: configParseResult.options.configFilePath,
-            optionsToExtend,
-            configFileSpecs: configParseResult.configFileSpecs,
-            configFileWildCardDirectories: configParseResult.wildcardDirectories
-        });
+        const watchCompilerHost = createWatchCompilerHost() as WatchCompilerHostOfConfigFile;
+        watchCompilerHost.onConfigFileDiagnostic = reportDiagnostic;
+        watchCompilerHost.rootFiles = configParseResult.fileNames;
+        watchCompilerHost.options = configParseResult.options;
+        watchCompilerHost.configFileName = configParseResult.options.configFilePath;
+        watchCompilerHost.optionsToExtend = optionsToExtend;
+        watchCompilerHost.configFileSpecs = configParseResult.configFileSpecs;
+        watchCompilerHost.configFileWildCardDirectories = configParseResult.wildcardDirectories;
+        createWatch(watchCompilerHost);
     }
 
     function createWatchOfFilesAndCompilerOptions(rootFiles: string[], options: CompilerOptions) {
-        createWatch({
-            system: sys,
-            beforeProgramCreate: enableStatistics,
-            afterProgramCreate: createProgramCompilerWithBuilderState(),
-            rootFiles,
-            options
-        });
+        const watchCompilerHost = createWatchCompilerHost() as WatchCompilerHostOfFilesAndCompilerOptions;
+        watchCompilerHost.rootFiles = rootFiles;
+        watchCompilerHost.options = options;
+        createWatch(watchCompilerHost);
     }
 
     function compileProgram(program: Program): ExitStatus {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -3306,14 +3306,14 @@ namespace ts {
 
     const carriageReturnLineFeed = "\r\n";
     const lineFeed = "\n";
-    export function getNewLineCharacter(options: CompilerOptions | PrinterOptions, system?: { newLine: string }): string {
+    export function getNewLineCharacter(options: CompilerOptions | PrinterOptions, getNewLine?: () => string): string {
         switch (options.newLine) {
             case NewLineKind.CarriageReturnLineFeed:
                 return carriageReturnLineFeed;
             case NewLineKind.LineFeed:
                 return lineFeed;
         }
-        return system ? system.newLine : sys ? sys.newLine : carriageReturnLineFeed;
+        return getNewLine ? getNewLine() : sys ? sys.newLine : carriageReturnLineFeed;
     }
 
     /**
diff --git a/src/compiler/watch.ts b/src/compiler/watch.ts
@@ -161,7 +161,7 @@ namespace ts {
         };
     }
 
-    export interface WatchHost {
+    export interface WatchCompilerHost {
         /** FS system to use */
         system: System;
 
@@ -170,14 +170,18 @@ namespace ts {
         /** If provided, callback to invoke after every new program creation */
         afterProgramCreate?(host: DirectoryStructureHost, program: Program): void;
 
-        /** Optional module name resolver */
+        // Sub set of compiler host methods to read and generate new program
+        useCaseSensitiveFileNames(): boolean;
+        getNewLine(): string;
+
+        /** If provided this function would be used to resolve the module names, otherwise typescript's default module resolution */
         resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames?: string[]): ResolvedModule[];
     }
 
     /**
      * Host to create watch with root files and options
      */
-    export interface WatchOfFilesAndCompilerOptionsHost extends WatchHost {
+    export interface WatchCompilerHostOfFilesAndCompilerOptions extends WatchCompilerHost {
         /** root files to use to generate program */
         rootFiles: string[];
 
@@ -188,7 +192,7 @@ namespace ts {
     /**
      * Host to create watch with config file
      */
-    export interface WatchOfConfigFileHost extends WatchHost {
+    export interface WatchCompilerHostOfConfigFile extends WatchCompilerHost {
         /** Name of the config file to compile */
         configFileName: string;
 
@@ -199,11 +203,11 @@ namespace ts {
         onConfigFileDiagnostic(diagnostic: Diagnostic): void;
     }
 
-    /*@internal*/
     /**
      * Host to create watch with config file that is already parsed (from tsc)
      */
-    export interface WatchOfConfigFileHost extends WatchHost {
+    /*@internal*/
+    export interface WatchCompilerHostOfConfigFile extends WatchCompilerHost {
         rootFiles?: string[];
         options?: CompilerOptions;
         optionsToExtend?: CompilerOptions;
@@ -234,39 +238,48 @@ namespace ts {
     }
 
     /**
-     * Create the watched program for config file
+     * Creates the watch compiler host that can be extended with config file or root file names and options host
      */
-    export function createWatchOfConfigFile(configFileName: string, optionsToExtend?: CompilerOptions, system = sys, reportDiagnostic?: DiagnosticReporter): WatchOfConfigFile {
-        return createWatch({
+    /*@internal*/
+    export function createWatchCompilerHost(system = sys, reportDiagnostic?: DiagnosticReporter): WatchCompilerHost {
+        return {
+            useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
+            getNewLine: () => system.newLine,
             system,
-            afterProgramCreate: createProgramCompilerWithBuilderState(system, reportDiagnostic),
-            onConfigFileDiagnostic: reportDiagnostic || createDiagnosticReporter(system),
-            configFileName,
-            optionsToExtend
-        });
+            afterProgramCreate: createProgramCompilerWithBuilderState(system, reportDiagnostic)
+        };
+    }
+
+    /**
+     * Create the watched program for config file
+     */
+    export function createWatchOfConfigFile(configFileName: string, optionsToExtend?: CompilerOptions, system?: System, reportDiagnostic?: DiagnosticReporter): WatchOfConfigFile {
+        const host = createWatchCompilerHost(system) as WatchCompilerHostOfConfigFile;
+        host.onConfigFileDiagnostic = reportDiagnostic || createDiagnosticReporter(system);
+        host.configFileName = configFileName;
+        host.optionsToExtend = optionsToExtend;
+        return createWatch(host);
     }
 
     /**
      * Create the watched program for root files and compiler options
      */
     export function createWatchOfFilesAndCompilerOptions(rootFiles: string[], options: CompilerOptions, system = sys, reportDiagnostic?: DiagnosticReporter): WatchOfFilesAndCompilerOptions {
-        return createWatch({
-            system,
-            afterProgramCreate: createProgramCompilerWithBuilderState(system, reportDiagnostic),
-            rootFiles,
-            options
-        });
+        const host = createWatchCompilerHost(system, reportDiagnostic) as WatchCompilerHostOfFilesAndCompilerOptions;
+        host.rootFiles = rootFiles;
+        host.options = options;
+        return createWatch(host);
     }
 
     /**
      * Creates the watch from the host for root files and compiler options
      */
-    export function createWatch(host: WatchOfFilesAndCompilerOptionsHost): WatchOfFilesAndCompilerOptions;
+    export function createWatch(host: WatchCompilerHostOfFilesAndCompilerOptions): WatchOfFilesAndCompilerOptions;
     /**
      * Creates the watch from the host for config file
      */
-    export function createWatch(host: WatchOfConfigFileHost): WatchOfConfigFile;
-    export function createWatch(host: WatchOfFilesAndCompilerOptionsHost | WatchOfConfigFileHost): WatchOfFilesAndCompilerOptions | WatchOfConfigFile {
+    export function createWatch(host: WatchCompilerHostOfConfigFile): WatchOfConfigFile;
+    export function createWatch(host: WatchCompilerHostOfFilesAndCompilerOptions | WatchCompilerHostOfConfigFile): WatchOfFilesAndCompilerOptions | WatchOfConfigFile {
         interface HostFileInfo {
             version: number;
             sourceFile: SourceFile;
@@ -284,10 +297,10 @@ namespace ts {
         let hasChangedCompilerOptions = false;                              // True if the compiler options have changed between compilations
         let hasChangedAutomaticTypeDirectiveNames = false;                  // True if the automatic type directives have changed
 
-        const { system, configFileName, onConfigFileDiagnostic, optionsToExtend: optionsToExtendForConfigFile = {} } = host as WatchOfConfigFileHost;
-        const beforeProgramCreate: WatchHost["beforeProgramCreate"] = host.beforeProgramCreate ? host.beforeProgramCreate.bind(host) : noop;
-        const afterProgramCreate: WatchHost["afterProgramCreate"] = host.afterProgramCreate ? host.afterProgramCreate.bind(host) : noop;
-        let { rootFiles: rootFileNames, options: compilerOptions, configFileSpecs, configFileWildCardDirectories } = host as WatchOfConfigFileHost;
+        const { system, configFileName, onConfigFileDiagnostic, optionsToExtend: optionsToExtendForConfigFile = {} } = host as WatchCompilerHostOfConfigFile;
+        const beforeProgramCreate: WatchCompilerHost["beforeProgramCreate"] = host.beforeProgramCreate ? host.beforeProgramCreate.bind(host) : noop;
+        const afterProgramCreate: WatchCompilerHost["afterProgramCreate"] = host.afterProgramCreate ? host.afterProgramCreate.bind(host) : noop;
+        let { rootFiles: rootFileNames, options: compilerOptions, configFileSpecs, configFileWildCardDirectories } = host as WatchCompilerHostOfConfigFile;
 
         // From tsc we want to get already parsed result and hence check for rootFileNames
         const directoryStructureHost = configFileName ? createCachedDirectoryStructureHost(system) : system;
@@ -296,7 +309,7 @@ namespace ts {
         }
 
         const loggingEnabled = compilerOptions.diagnostics || compilerOptions.extendedDiagnostics;
-        const writeLog: (s: string) => void = loggingEnabled ? s => { system.write(s); system.write(system.newLine); } : noop;
+        const writeLog: (s: string) => void = loggingEnabled ? s => { system.write(s); system.write(newLine); } : noop;
         const watchFile = compilerOptions.extendedDiagnostics ? ts.addFileWatcherWithLogging : loggingEnabled ? ts.addFileWatcherWithOnlyTriggerLogging : ts.addFileWatcher;
         const watchFilePath = compilerOptions.extendedDiagnostics ? ts.addFilePathWatcherWithLogging : ts.addFilePathWatcher;
         const watchDirectoryWorker = compilerOptions.extendedDiagnostics ? ts.addDirectoryWatcherWithLogging : ts.addDirectoryWatcher;
@@ -308,8 +321,9 @@ namespace ts {
         const getCurrentDirectory = memoize(() => directoryStructureHost.getCurrentDirectory());
         const realpath = system.realpath && ((path: string) => system.realpath(path));
         const getCachedDirectoryStructureHost = configFileName && (() => directoryStructureHost as CachedDirectoryStructureHost);
-        const getCanonicalFileName = createGetCanonicalFileName(system.useCaseSensitiveFileNames);
-        let newLine = getNewLineCharacter(compilerOptions, system);
+        const useCaseSensitiveFileNames = memoize(() => host.useCaseSensitiveFileNames());
+        const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames());
+        let newLine = updateNewLine();
 
         const compilerHost: CompilerHost & ResolutionCacheHost = {
             // Members for CompilerHost
@@ -319,7 +333,7 @@ namespace ts {
             getDefaultLibFileName: options => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),
             writeFile: notImplemented,
             getCurrentDirectory,
-            useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
+            useCaseSensitiveFileNames,
             getCanonicalFileName,
             getNewLine: () => newLine,
             fileExists,
@@ -370,7 +384,7 @@ namespace ts {
             writeLog(`Synchronizing program`);
 
             if (hasChangedCompilerOptions) {
-                newLine = getNewLineCharacter(compilerOptions, system);
+                newLine = updateNewLine();
                 if (program && changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) {
                     resolutionCache.clear();
                 }
@@ -423,6 +437,10 @@ namespace ts {
             scheduleProgramUpdate();
         }
 
+        function updateNewLine() {
+            return getNewLineCharacter(compilerOptions, () => host.getNewLine());
+        }
+
         function toPath(fileName: string) {
             return ts.toPath(fileName, getCurrentDirectory(), getCanonicalFileName);
         }
diff --git a/src/server/project.ts b/src/server/project.ts
@@ -266,7 +266,7 @@ namespace ts.server {
         }
 
         getNewLine() {
-            return this.directoryStructureHost.newLine;
+            return this.projectService.host.newLine;
         }
 
         getProjectVersion() {
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -1255,7 +1255,7 @@ namespace ts {
                 getCancellationToken: () => cancellationToken,
                 getCanonicalFileName,
                 useCaseSensitiveFileNames: () => useCaseSensitivefileNames,
-                getNewLine: () => getNewLineCharacter(newSettings, { newLine: getNewLineOrDefaultFromHost(host) }),
+                getNewLine: () => getNewLineCharacter(newSettings, () => getNewLineOrDefaultFromHost(host)),
                 getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
                 writeFile: noop,
                 getCurrentDirectory: () => currentDirectory,
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -2729,9 +2729,7 @@ declare namespace ts {
      * Partial interface of the System thats needed to support the caching of directory structure
      */
     interface DirectoryStructureHost {
-        newLine: string;
         useCaseSensitiveFileNames: boolean;
-        write(s: string): void;
         readFile(path: string, encoding?: string): string | undefined;
         writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
         fileExists(path: string): boolean;
@@ -2743,7 +2741,9 @@ declare namespace ts {
         exit(exitCode?: number): void;
     }
     interface System extends DirectoryStructureHost {
+        newLine: string;
         args: string[];
+        write(s: string): void;
         getFileSize?(path: string): number;
         /**
          * @pollingInterval - this parameter is used in polling-based watchers and ignored in watchers that
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts

Original file line number	Diff line number	Diff line change
`@@ -266,7 +266,7 @@ namespace ts.server {`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`getNewLine() {`
`269`		`- return this.directoryStructureHost.newLine;`
	`269`	`+ return this.projectService.host.newLine;`
`270`	`270`	`}`
`271`	`271`
`272`	`272`	`getProjectVersion() {`