Builder to use project reference redirects to output in the dependencies instead of source files

sheetalkamat · sheetalkamat · commit aac961e60db0 · 2018-09-17T12:18:59.000-07:00
diff --git a/src/compiler/builderState.ts b/src/compiler/builderState.ts
@@ -88,7 +88,7 @@ namespace ts.BuilderState {
     function getReferencedFileFromImportedModuleSymbol(symbol: Symbol) {
         if (symbol.declarations && symbol.declarations[0]) {
             const declarationSourceFile = getSourceFileOfNode(symbol.declarations[0]);
-            return declarationSourceFile && declarationSourceFile.path;
+            return declarationSourceFile && (declarationSourceFile.resolvedPath || declarationSourceFile.path);
         }
     }
 
@@ -100,6 +100,13 @@ namespace ts.BuilderState {
         return symbol && getReferencedFileFromImportedModuleSymbol(symbol);
     }
 
+    /**
+     * Gets the path to reference file from file name, it could be resolvedPath if present otherwise path
+     */
+    function getReferencedFileFromFileName(program: Program, fileName: string, sourceFileDirectory: Path, getCanonicalFileName: GetCanonicalFileName): Path {
+        return toPath(program.getProjectReferenceRedirect(fileName) || fileName, sourceFileDirectory, getCanonicalFileName);
+    }
+
     /**
      * Gets the referenced files for a file from the program with values for the keys as referenced file's path to be true
      */
@@ -123,7 +130,7 @@ namespace ts.BuilderState {
         // Handle triple slash references
         if (sourceFile.referencedFiles && sourceFile.referencedFiles.length > 0) {
             for (const referencedFile of sourceFile.referencedFiles) {
-                const referencedPath = toPath(referencedFile.fileName, sourceFileDirectory, getCanonicalFileName);
+                const referencedPath = getReferencedFileFromFileName(program, referencedFile.fileName, sourceFileDirectory, getCanonicalFileName);
                 addReferencedFile(referencedPath);
             }
         }
@@ -136,7 +143,7 @@ namespace ts.BuilderState {
                 }
 
                 const fileName = resolvedTypeReferenceDirective.resolvedFileName!; // TODO: GH#18217
-                const typeFilePath = toPath(fileName, sourceFileDirectory, getCanonicalFileName);
+                const typeFilePath = getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName);
                 addReferencedFile(typeFilePath);
             });
         }
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
@@ -758,7 +758,8 @@ namespace ts {
             getConfigFileParsingDiagnostics,
             getResolvedModuleWithFailedLookupLocationsFromCache,
             getProjectReferences,
-            getResolvedProjectReferences
+            getResolvedProjectReferences,
+            getProjectReferenceRedirect
         };
 
         verifyCompilerOptions();
diff --git a/src/compiler/tsbuild.ts b/src/compiler/tsbuild.ts
@@ -862,7 +862,7 @@ namespace ts {
             if (buildProject) {
                 buildSingleInvalidatedProject(buildProject.project, buildProject.reloadLevel);
                 if (hasPendingInvalidatedProjects()) {
-                    if (!timerToBuildInvalidatedProject) {
+                    if (options.watch && !timerToBuildInvalidatedProject) {
                         scheduleBuildInvalidatedProject();
                     }
                 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2551,6 +2551,11 @@ namespace ts {
         fileName: string;
         /* @internal */ path: Path;
         text: string;
+        /** Resolved path can be different from path property,
+         * when file is included through project reference is mapped to its output instead of source
+         * in that case resolvedPath = path to output file
+         * path = input file's path
+         */
         /* @internal */ resolvedPath: Path;
 
         /**
@@ -2819,6 +2824,7 @@ namespace ts {
 
         getProjectReferences(): ReadonlyArray<ProjectReference> | undefined;
         getResolvedProjectReferences(): (ResolvedProjectReference | undefined)[] | undefined;
+        /*@internal*/ getProjectReferenceRedirect(fileName: string): string | undefined;
     }
 
     /* @internal */
diff --git a/src/harness/virtualFileSystemWithWatch.ts b/src/harness/virtualFileSystemWithWatch.ts
@@ -934,7 +934,12 @@ interface Array<T> {}`
             const folder = this.fs.get(base) as FsFolder;
             Debug.assert(isFsFolder(folder));
 
-            this.addFileOrFolderInFolder(folder, file);
+            if (!this.fs.has(file.path)) {
+                this.addFileOrFolderInFolder(folder, file);
+            }
+            else {
+                this.modifyFile(path, content);
+            }
         }
 
         write(message: string) {
diff --git a/src/testRunner/unittests/tsbuildWatchMode.ts b/src/testRunner/unittests/tsbuildWatchMode.ts
@@ -94,6 +94,7 @@ namespace ts.tscWatch {
         const ui = subProjectFiles(SubProject.ui);
         const allFiles: ReadonlyArray<File> = [libFile, ...core, ...logic, ...tests, ...ui];
         const testProjectExpectedWatchedFiles = [core[0], core[1], core[2], ...logic, ...tests].map(f => f.path);
+        const testProjectExpectedWatchedDirectoriesRecursive = [projectPath(SubProject.core), projectPath(SubProject.logic)];
 
         function createSolutionInWatchMode(allFiles: ReadonlyArray<File>, defaultOptions?: BuildOptions, disableConsoleClears?: boolean) {
             const host = createWatchedSystem(allFiles, { currentDirectory: projectsLocation });
@@ -110,7 +111,7 @@ namespace ts.tscWatch {
         function verifyWatches(host: WatchedSystem) {
             checkWatchedFiles(host, testProjectExpectedWatchedFiles);
             checkWatchedDirectories(host, emptyArray, /*recursive*/ false);
-            checkWatchedDirectories(host, [projectPath(SubProject.core), projectPath(SubProject.logic)], /*recursive*/ true);
+            checkWatchedDirectories(host, testProjectExpectedWatchedDirectoriesRecursive, /*recursive*/ true);
         }
 
         it("creates solution in watch mode", () => {
@@ -161,7 +162,7 @@ namespace ts.tscWatch {
                     function verifyWatches() {
                         checkWatchedFiles(host, additionalFiles ? testProjectExpectedWatchedFiles.concat(newFile.path) : testProjectExpectedWatchedFiles);
                         checkWatchedDirectories(host, emptyArray, /*recursive*/ false);
-                        checkWatchedDirectories(host, [projectPath(SubProject.core), projectPath(SubProject.logic)], /*recursive*/ true);
+                        checkWatchedDirectories(host, testProjectExpectedWatchedDirectoriesRecursive, /*recursive*/ true);
                     }
                 }
 
@@ -347,7 +348,7 @@ function myFunc() { return 100; }`);
             function verifyWatches() {
                 checkWatchedFiles(host, projectFiles.map(f => f.path));
                 checkWatchedDirectories(host, emptyArray, /*recursive*/ false);
-                checkWatchedDirectories(host, [projectPath(SubProject.core), projectPath(SubProject.logic)], /*recursive*/ true);
+                checkWatchedDirectories(host, testProjectExpectedWatchedDirectoriesRecursive, /*recursive*/ true);
             }
         });
 
@@ -389,12 +390,87 @@ let x: string = 10;`);
             });
         });
 
-        it("tsc-watch works with project references", () => {
-            // Build the composite project
-            const host = createSolutionInWatchMode(allFiles);
+        describe("tsc-watch works with project references", () => {
+            const coreIndexDts = projectFilePath(SubProject.core, "index.d.ts");
+            const coreAnotherModuleDts = projectFilePath(SubProject.core, "anotherModule.d.ts");
+            const logicIndexDts = projectFilePath(SubProject.logic, "index.d.ts");
+            const expectedWatchedFiles = [core[0], logic[0], ...tests, libFile].map(f => f.path).concat(coreIndexDts, coreAnotherModuleDts, logicIndexDts);
+            const expectedWatchedDirectoriesRecursive = projectSystem.getTypeRootsFromLocation(projectPath(SubProject.tests));
+
+            function createSolution() {
+                const host = createWatchedSystem(allFiles, { currentDirectory: projectsLocation });
+                const solutionBuilder = createSolutionBuilder(host, [`${project}/${SubProject.tests}`], {});
+                return { host, solutionBuilder };
+            }
 
-            createWatchOfConfigFile(tests[0].path, host);
-            checkOutputErrorsInitial(host, emptyArray);
+            function createBuiltSolution() {
+                const result = createSolution();
+                const { host, solutionBuilder } = result;
+                solutionBuilder.buildAllProjects();
+                const outputFileStamps = getOutputFileStamps(host);
+                for (const stamp of outputFileStamps) {
+                    assert.isDefined(stamp[1], `${stamp[0]} expected to be present`);
+                }
+                return result;
+            }
+
+            function verifyWatches(host: WatchedSystem) {
+                checkWatchedFilesDetailed(host, expectedWatchedFiles, 1);
+                checkWatchedDirectories(host, emptyArray, /*recursive*/ false);
+                checkWatchedDirectoriesDetailed(host, expectedWatchedDirectoriesRecursive, 1, /*recursive*/ true);
+            }
+
+            function createSolutionAndWatchMode() {
+                // Build the composite project
+                const { host, solutionBuilder } = createBuiltSolution();
+
+                // Build in watch mode
+                const watch = createWatchOfConfigFileReturningBuilder(tests[0].path, host);
+                checkOutputErrorsInitial(host, emptyArray);
+
+                return { host, solutionBuilder, watch };
+            }
+
+            function verifyDependencies(watch: () => BuilderProgram, filePath: string, expected: ReadonlyArray<string>) {
+                checkArray(`${filePath} dependencies`, watch().getAllDependencies(watch().getSourceFile(filePath)!).map(f => f.toLocaleLowerCase()), expected);
+            }
+
+            describe("invoking when references are already built", () => {
+                it("verifies dependencies and watches", () => {
+                    const { host, watch } = createSolutionAndWatchMode();
+
+                    verifyWatches(host);
+                    verifyDependencies(watch, coreIndexDts, [coreIndexDts]);
+                    verifyDependencies(watch, coreAnotherModuleDts, [coreAnotherModuleDts]);
+                    verifyDependencies(watch, logicIndexDts, [logicIndexDts, coreAnotherModuleDts]);
+                    verifyDependencies(watch, tests[1].path, [tests[1].path, coreAnotherModuleDts, logicIndexDts, coreAnotherModuleDts]);
+                });
+
+                it("local edit in ts file, result in watch compilation because logic.d.ts is written", () => {
+                    const { host, solutionBuilder } = createSolutionAndWatchMode();
+                    host.writeFile(logic[1].path, `${logic[1].content}
+function foo() {
+}`);
+                    solutionBuilder.invalidateProject(`${project}/${SubProject.logic}`);
+                    solutionBuilder.buildInvalidatedProject();
+
+                    host.checkTimeoutQueueLengthAndRun(1); // not ideal, but currently because of d.ts but no new file is written
+                    checkOutputErrorsIncremental(host, emptyArray);
+                });
+
+                it("non local edit in ts file, rebuilds in watch compilation", () => {
+                    const { host, solutionBuilder } = createSolutionAndWatchMode();
+                    host.writeFile(logic[1].path, `${logic[1].content}
+export function gfoo() {
+}`);
+                    solutionBuilder.invalidateProject(logic[0].path);
+                    solutionBuilder.buildInvalidatedProject();
+
+                    host.checkTimeoutQueueLengthAndRun(1);
+                    checkOutputErrorsIncremental(host, emptyArray);
+                });
+
+            });
         });
     });
 }
diff --git a/src/testRunner/unittests/tscWatchMode.ts b/src/testRunner/unittests/tscWatchMode.ts
@@ -20,6 +20,13 @@ namespace ts.tscWatch {
         checkArray(`Program rootFileNames`, program.getRootFileNames(), expectedFiles);
     }
 
+    export function createWatchOfConfigFileReturningBuilder(configFileName: string, host: WatchedSystem, maxNumberOfFilesToIterateForInvalidation?: number) {
+        const compilerHost = createWatchCompilerHostOfConfigFile(configFileName, {}, host);
+        compilerHost.maxNumberOfFilesToIterateForInvalidation = maxNumberOfFilesToIterateForInvalidation;
+        const watch = createWatchProgram(compilerHost);
+        return () => watch.getCurrentProgram();
+    }
+
     export function createWatchOfConfigFile(configFileName: string, host: WatchedSystem, maxNumberOfFilesToIterateForInvalidation?: number) {
         const compilerHost = createWatchCompilerHostOfConfigFile(configFileName, {}, host);
         compilerHost.maxNumberOfFilesToIterateForInvalidation = maxNumberOfFilesToIterateForInvalidation;

Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ namespace ts.BuilderState {`
`88`	`88`	`function getReferencedFileFromImportedModuleSymbol(symbol: Symbol) {`
`89`	`89`	`if (symbol.declarations && symbol.declarations[0]) {`
`90`	`90`	`const declarationSourceFile = getSourceFileOfNode(symbol.declarations[0]);`
`91`		`- return declarationSourceFile && declarationSourceFile.path;`
	`91`	`+ return declarationSourceFile && (declarationSourceFile.resolvedPath \|\| declarationSourceFile.path);`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`@@ -100,6 +100,13 @@ namespace ts.BuilderState {`
`100`	`100`	`return symbol && getReferencedFileFromImportedModuleSymbol(symbol);`
`101`	`101`	`}`
`102`	`102`
	`103`	`+ /**`
	`104`	`+ * Gets the path to reference file from file name, it could be resolvedPath if present otherwise path`
	`105`	`+ */`
	`106`	`+ function getReferencedFileFromFileName(program: Program, fileName: string, sourceFileDirectory: Path, getCanonicalFileName: GetCanonicalFileName): Path {`
	`107`	`+ return toPath(program.getProjectReferenceRedirect(fileName) \|\| fileName, sourceFileDirectory, getCanonicalFileName);`
	`108`	`+ }`
	`109`	`+`
`103`	`110`	`/**`
`104`	`111`	`* Gets the referenced files for a file from the program with values for the keys as referenced file's path to be true`
`105`	`112`	`*/`
`@@ -123,7 +130,7 @@ namespace ts.BuilderState {`
`123`	`130`	`// Handle triple slash references`
`124`	`131`	`if (sourceFile.referencedFiles && sourceFile.referencedFiles.length > 0) {`
`125`	`132`	`for (const referencedFile of sourceFile.referencedFiles) {`
`126`		`- const referencedPath = toPath(referencedFile.fileName, sourceFileDirectory, getCanonicalFileName);`
	`133`	`+ const referencedPath = getReferencedFileFromFileName(program, referencedFile.fileName, sourceFileDirectory, getCanonicalFileName);`
`127`	`134`	`addReferencedFile(referencedPath);`
`128`	`135`	`}`
`129`	`136`	`}`
`@@ -136,7 +143,7 @@ namespace ts.BuilderState {`
`136`	`143`	`}`
`137`	`144`
`138`	`145`	`const fileName = resolvedTypeReferenceDirective.resolvedFileName!; // TODO: GH#18217`
`139`		`- const typeFilePath = toPath(fileName, sourceFileDirectory, getCanonicalFileName);`
	`146`	`+ const typeFilePath = getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName);`
`140`	`147`	`addReferencedFile(typeFilePath);`
`141`	`148`	`});`
`142`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -862,7 +862,7 @@ namespace ts {`
`862`	`862`	`if (buildProject) {`
`863`	`863`	`buildSingleInvalidatedProject(buildProject.project, buildProject.reloadLevel);`
`864`	`864`	`if (hasPendingInvalidatedProjects()) {`
`865`		`- if (!timerToBuildInvalidatedProject) {`
	`865`	`+ if (options.watch && !timerToBuildInvalidatedProject) {`
`866`	`866`	`scheduleBuildInvalidatedProject();`
`867`	`867`	`}`
`868`	`868`	`}`