Source of project reference behave as if those files cannot be emitted.

Author: sheetalkamat

src/compiler/sys.ts

@@ -472,6 +472,33 @@ namespace ts {
         }
     }
 
+    function recursiveCreateDirectory(directoryPath: string, sys: System) {
+        const basePath = getDirectoryPath(directoryPath);
+        const shouldCreateParent = basePath !== "" && directoryPath !== basePath && !sys.directoryExists(basePath);
+        if (shouldCreateParent) {
+            recursiveCreateDirectory(basePath, sys);
+        }
+        if (shouldCreateParent || !sys.directoryExists(directoryPath)) {
+            sys.createDirectory(directoryPath);
+        }
+    }
+
+    /**
+     * patch writefile to create folder before writing the file
+     */
+    /*@internal*/
+    export function patchWriteFileEnsuringDirectory(sys: System) {
+        // patch writefile to create folder before writing the file
+        const originalWriteFile = sys.writeFile;
+        sys.writeFile = (path, data, writeBom) => {
+            const directoryPath = getDirectoryPath(normalizeSlashes(path));
+            if (directoryPath && !sys.directoryExists(directoryPath)) {
+                recursiveCreateDirectory(directoryPath, sys);
+            }
+            originalWriteFile.call(sys, path, data, writeBom);
+        };
+    }
+
     /*@internal*/
     interface NodeBuffer extends Uint8Array {
         write(str: string, offset?: number, length?: number, encoding?: string): number;
@@ -1259,17 +1286,6 @@ namespace ts {
             };
         }
 
-        function recursiveCreateDirectory(directoryPath: string, sys: System) {
-            const basePath = getDirectoryPath(directoryPath);
-            const shouldCreateParent = basePath !== "" && directoryPath !== basePath && !sys.directoryExists(basePath);
-            if (shouldCreateParent) {
-                recursiveCreateDirectory(basePath, sys);
-            }
-            if (shouldCreateParent || !sys.directoryExists(directoryPath)) {
-                sys.createDirectory(directoryPath);
-            }
-        }
-
         let sys: System | undefined;
         if (typeof ChakraHost !== "undefined") {
             sys = getChakraSystem();
@@ -1281,14 +1297,7 @@ namespace ts {
         }
         if (sys) {
             // patch writefile to create folder before writing the file
-            const originalWriteFile = sys.writeFile;
-            sys.writeFile = (path, data, writeBom) => {
-                const directoryPath = getDirectoryPath(normalizeSlashes(path));
-                if (directoryPath && !sys!.directoryExists(directoryPath)) {
-                    recursiveCreateDirectory(directoryPath, sys!);
-                }
-                originalWriteFile.call(sys, path, data, writeBom);
-            };
+            patchWriteFileEnsuringDirectory(sys);
         }
         return sys!;
     })();

src/harness/virtualFileSystemWithWatch.ts

@@ -66,6 +66,8 @@ interface Array<T> {}`
             params.newLine,
             params.useWindowsStylePaths,
             params.environmentVariables);
+        // Just like sys, patch the host to use writeFile
+        patchWriteFileEnsuringDirectory(host);
         return host;
     }
 
@@ -990,6 +992,19 @@ interface Array<T> {}`
         }
     }
 
+    export type TestServerHostTrackingWrittenFiles = TestServerHost & { writtenFiles: Map<true>; };
+
+    export function changeToHostTrackingWrittenFiles(inputHost: TestServerHost) {
+        const host = inputHost as TestServerHostTrackingWrittenFiles;
+        const originalWriteFile = host.writeFile;
+        host.writtenFiles = createMap<true>();
+        host.writeFile = (fileName, content) => {
+            originalWriteFile.call(host, fileName, content);
+            const path = host.toFullPath(fileName);
+            host.writtenFiles.set(path, true);
+        };
+        return host;
+    }
     export const tsbuildProjectsLocation = "/user/username/projects";
     export function getTsBuildProjectFilePath(project: string, file: string) {
         return `${tsbuildProjectsLocation}/${project}/${file}`;

src/server/project.ts

@@ -537,8 +537,11 @@ namespace ts.server {
             return this.projectService.getSourceFileLike(fileName, this);
         }
 
-        private shouldEmitFile(scriptInfo: ScriptInfo) {
-            return scriptInfo && !scriptInfo.isDynamicOrHasMixedContent();
+        /*@internal*/
+        shouldEmitFile(scriptInfo: ScriptInfo | undefined) {
+            return scriptInfo &&
+                !scriptInfo.isDynamicOrHasMixedContent() &&
+                !this.program!.isSourceOfProjectReferenceRedirect(scriptInfo.path);
         }
 
         getCompileOnSaveAffectedFileList(scriptInfo: ScriptInfo): string[] {
@@ -548,7 +551,7 @@ namespace ts.server {
             updateProjectIfDirty(this);
             this.builderState = BuilderState.create(this.program!, this.projectService.toCanonicalFileName, this.builderState);
             return mapDefined(BuilderState.getFilesAffectedBy(this.builderState, this.program!, scriptInfo.path, this.cancellationToken, data => this.projectService.host.createHash!(data)), // TODO: GH#18217
-                sourceFile => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)!) ? sourceFile.fileName : undefined);
+                sourceFile => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)) ? sourceFile.fileName : undefined);
         }
 
         /**

src/server/session.ts

@@ -1030,7 +1030,9 @@ namespace ts.server {
 
         private getEmitOutput(args: protocol.FileRequestArgs): EmitOutput {
             const { file, project } = this.getFileAndProject(args);
-            return project.getLanguageService().getEmitOutput(file);
+            return project.shouldEmitFile(project.getScriptInfo(file)) ?
+                project.getLanguageService().getEmitOutput(file) :
+                { emitSkipped: true, outputFiles: [] };
         }
 
         private mapDefinitionInfo(definitions: ReadonlyArray<DefinitionInfo>, project: Project): ReadonlyArray<protocol.FileSpanWithContext> {

src/testRunner/tsconfig.json

@@ -137,6 +137,7 @@
         "unittests/tsserver/occurences.ts",
         "unittests/tsserver/openFile.ts",
         "unittests/tsserver/projectErrors.ts",
+        "unittests/tsserver/projectReferenceCompileOnSave.ts",
         "unittests/tsserver/projectReferenceErrors.ts",
         "unittests/tsserver/projectReferences.ts",
         "unittests/tsserver/projects.ts",

src/testRunner/unittests/tsbuildWatchMode.ts

@@ -2,18 +2,12 @@ namespace ts.tscWatch {
     import projectsLocation = TestFSWithWatch.tsbuildProjectsLocation;
     import getFilePathInProject = TestFSWithWatch.getTsBuildProjectFilePath;
     import getFileFromProject = TestFSWithWatch.getTsBuildProjectFile;
-    type TsBuildWatchSystem = WatchedSystem & { writtenFiles: Map<true>; };
+    type TsBuildWatchSystem = TestFSWithWatch.TestServerHostTrackingWrittenFiles;
 
     function createTsBuildWatchSystem(fileOrFolderList: ReadonlyArray<TestFSWithWatch.FileOrFolderOrSymLink>, params?: TestFSWithWatch.TestServerHostCreationParameters) {
-        const host = createWatchedSystem(fileOrFolderList, params) as TsBuildWatchSystem;
-        const originalWriteFile = host.writeFile;
-        host.writtenFiles = createMap<true>();
-        host.writeFile = (fileName, content) => {
-            originalWriteFile.call(host, fileName, content);
-            const path = host.toFullPath(fileName);
-            host.writtenFiles.set(path, true);
-        };
-        return host;
+        return TestFSWithWatch.changeToHostTrackingWrittenFiles(
+            createWatchedSystem(fileOrFolderList, params)
+        );
     }
 
     export function createSolutionBuilder(system: WatchedSystem, rootNames: ReadonlyArray<string>, defaultOptions?: BuildOptions) {

src/testRunner/unittests/tsserver/helpers.ts

@@ -498,7 +498,7 @@ namespace ts.projectSystem {
         return protocolToLocation(str)(start);
     }
 
-    function protocolToLocation(text: string): (pos: number) => protocol.Location {
+    export function protocolToLocation(text: string): (pos: number) => protocol.Location {
         const lineStarts = computeLineStarts(text);
         return pos => {
             const x = computeLineAndCharacterOfPosition(lineStarts, pos);