Merge pull request #27155 from Microsoft/fixIncrementalWatchProjectWithReferences

sheetalkamat · web-flow · commit e3026b0eb31f · 2018-09-17T15:34:40.000-07:00
Fix incremental watch when project built has project references
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/core.ts b/src/compiler/core.ts
@@ -842,7 +842,7 @@ namespace ts {
         return deduplicateSorted(sort(array, comparer), equalityComparer || comparer);
     }
 
-    export function arrayIsEqualTo<T>(array1: ReadonlyArray<T> | undefined, array2: ReadonlyArray<T> | undefined, equalityComparer: (a: T, b: T) => boolean = equateValues): boolean {
+    export function arrayIsEqualTo<T>(array1: ReadonlyArray<T> | undefined, array2: ReadonlyArray<T> | undefined, equalityComparer: (a: T, b: T, index: number) => boolean = equateValues): boolean {
         if (!array1 || !array2) {
             return array1 === array2;
         }
@@ -852,7 +852,7 @@ namespace ts {
         }
 
         for (let i = 0; i < array1.length; i++) {
-            if (!equalityComparer(array1[i], array2[i])) {
+            if (!equalityComparer(array1[i], array2[i], i)) {
                 return false;
             }
         }
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
@@ -455,7 +455,7 @@ namespace ts {
         }
 
         // If project references dont match
-        if (!arrayIsEqualTo(program.getProjectReferences(), projectReferences)) {
+        if (!arrayIsEqualTo(program.getProjectReferences(), projectReferences, projectReferenceUptoDate)) {
             return false;
         }
 
@@ -483,9 +483,27 @@ namespace ts {
 
         return true;
 
-        function sourceFileNotUptoDate(sourceFile: SourceFile): boolean {
-            return sourceFile.version !== getSourceVersion(sourceFile.path) ||
-                hasInvalidatedResolution(sourceFile.path);
+        function sourceFileNotUptoDate(sourceFile: SourceFile) {
+            return !sourceFileVersionUptoDate(sourceFile) ||
+                hasInvalidatedResolution(sourceFile.resolvedPath || sourceFile.path);
+        }
+
+        function sourceFileVersionUptoDate(sourceFile: SourceFile) {
+            return sourceFile.version === getSourceVersion(sourceFile.resolvedPath || sourceFile.path);
+        }
+
+        function projectReferenceUptoDate(oldRef: ProjectReference, newRef: ProjectReference, index: number) {
+            if (!projectReferenceIsEqualTo(oldRef, newRef)) {
+                return false;
+            }
+            const oldResolvedRef = program!.getResolvedProjectReferences()![index];
+            if (oldResolvedRef) {
+                // If sourceFile for the oldResolvedRef existed, check the version for uptodate
+                return sourceFileVersionUptoDate(oldResolvedRef.sourceFile);
+            }
+            // In old program, not able to resolve project reference path,
+            // so if config file doesnt exist, it is uptodate.
+            return !fileExists(resolveProjectReferencePath(oldRef));
         }
     }
 
@@ -658,8 +676,9 @@ namespace ts {
                     const parsedRef = parseProjectReferenceConfigFile(ref);
                     resolvedProjectReferences!.push(parsedRef);
                     if (parsedRef) {
-                        if (parsedRef.commandLine.options.outFile) {
-                            const dtsOutfile = changeExtension(parsedRef.commandLine.options.outFile, ".d.ts");
+                        const out = parsedRef.commandLine.options.outFile || parsedRef.commandLine.options.out;
+                        if (out) {
+                            const dtsOutfile = changeExtension(out, ".d.ts");
                             processSourceFile(dtsOutfile, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined);
                         }
                         addProjectReferenceRedirects(parsedRef.commandLine, projectReferenceRedirects);
@@ -758,7 +777,8 @@ namespace ts {
             getConfigFileParsingDiagnostics,
             getResolvedModuleWithFailedLookupLocationsFromCache,
             getProjectReferences,
-            getResolvedProjectReferences
+            getResolvedProjectReferences,
+            getProjectReferenceRedirect
         };
 
         verifyCompilerOptions();
@@ -1225,6 +1245,13 @@ namespace ts {
             }
             resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();
             resolvedProjectReferences = oldProgram.getResolvedProjectReferences();
+            if (resolvedProjectReferences) {
+                resolvedProjectReferences.forEach(ref => {
+                    if (ref) {
+                        addProjectReferenceRedirects(ref.commandLine, projectReferenceRedirects);
+                    }
+                });
+            }
 
             sourceFileToPackageName = oldProgram.sourceFileToPackageName;
             redirectTargetsMap = oldProgram.redirectTargetsMap;
@@ -1280,12 +1307,13 @@ namespace ts {
                 const ref = projectReferences[i];
                 const resolvedRefOpts = resolvedProjectReferences![i]!.commandLine;
                 if (ref.prepend && resolvedRefOpts && resolvedRefOpts.options) {
+                    const out = resolvedRefOpts.options.outFile || resolvedRefOpts.options.out;
                     // Upstream project didn't have outFile set -- skip (error will have been issued earlier)
-                    if (!resolvedRefOpts.options.outFile) continue;
+                    if (!out) continue;
 
-                    const dtsFilename = changeExtension(resolvedRefOpts.options.outFile, ".d.ts");
-                    const js = host.readFile(resolvedRefOpts.options.outFile) || `/* Input file ${resolvedRefOpts.options.outFile} was missing */\r\n`;
-                    const jsMapPath = resolvedRefOpts.options.outFile + ".map"; // TODO: try to read sourceMappingUrl comment from the file
+                    const dtsFilename = changeExtension(out, ".d.ts");
+                    const js = host.readFile(out) || `/* Input file ${out} was missing */\r\n`;
+                    const jsMapPath = out + ".map"; // TODO: try to read sourceMappingUrl comment from the file
                     const jsMap = host.readFile(jsMapPath);
                     const dts = host.readFile(dtsFilename) || `/* Input file ${dtsFilename} was missing */\r\n`;
                     const dtsMapPath = dtsFilename + ".map";
@@ -2427,9 +2455,10 @@ namespace ts {
                         createDiagnosticForReference(i, Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path);
                     }
                     if (ref.prepend) {
-                        if (resolvedRefOpts.outFile) {
-                            if (!host.fileExists(resolvedRefOpts.outFile)) {
-                                createDiagnosticForReference(i, Diagnostics.Output_file_0_from_project_1_does_not_exist, resolvedRefOpts.outFile, ref.path);
+                        const out = resolvedRefOpts.outFile || resolvedRefOpts.out;
+                        if (out) {
+                            if (!host.fileExists(out)) {
+                                createDiagnosticForReference(i, Diagnostics.Output_file_0_from_project_1_does_not_exist, out, ref.path);
                             }
                         }
                         else {
diff --git a/src/compiler/tsbuild.ts b/src/compiler/tsbuild.ts
@@ -285,16 +285,17 @@ namespace ts {
     }
 
     function getOutFileOutputs(project: ParsedCommandLine): ReadonlyArray<string> {
-        if (!project.options.outFile) {
+        const out = project.options.outFile || project.options.out;
+        if (!out) {
             return Debug.fail("outFile must be set");
         }
         const outputs: string[] = [];
-        outputs.push(project.options.outFile);
+        outputs.push(out);
         if (project.options.sourceMap) {
-            outputs.push(`${project.options.outFile}.map`);
+            outputs.push(`${out}.map`);
         }
         if (getEmitDeclarations(project.options)) {
-            const dts = changeExtension(project.options.outFile, Extension.Dts);
+            const dts = changeExtension(out, Extension.Dts);
             outputs.push(dts);
             if (project.options.declarationMap) {
                 outputs.push(`${dts}.map`);
@@ -862,7 +863,7 @@ namespace ts {
             if (buildProject) {
                 buildSingleInvalidatedProject(buildProject.project, buildProject.reloadLevel);
                 if (hasPendingInvalidatedProjects()) {
-                    if (!timerToBuildInvalidatedProject) {
+                    if (options.watch && !timerToBuildInvalidatedProject) {
                         scheduleBuildInvalidatedProject();
                     }
                 }
@@ -1248,7 +1249,7 @@ namespace ts {
     }
 
     export function getAllProjectOutputs(project: ParsedCommandLine): ReadonlyArray<string> {
-        if (project.options.outFile) {
+        if (project.options.outFile || project.options.out) {
             return getOutFileOutputs(project);
         }
         else {
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
@@ -187,9 +187,10 @@ interface Array<T> {}`
     }
 
     export function checkArray(caption: string, actual: ReadonlyArray<string>, expected: ReadonlyArray<string>) {
+        checkMapKeys(caption, arrayToMap(actual, identity), expected);
         assert.equal(actual.length, expected.length, `${caption}: incorrect actual number of files, expected:\r\n${expected.join("\r\n")}\r\ngot: ${actual.join("\r\n")}`);
         for (const f of expected) {
-            assert.equal(true, contains(actual, f), `${caption}: expected to find ${f} in ${actual}`);
+            assert.isTrue(contains(actual, f), `${caption}: expected to find ${f} in ${actual}`);
         }
     }
 
@@ -934,7 +935,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
diff --git a/src/testRunner/unittests/tscWatchMode.ts b/src/testRunner/unittests/tscWatchMode.ts

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
`@@ -842,7 +842,7 @@ namespace ts {`
`842`	`842`	`return deduplicateSorted(sort(array, comparer), equalityComparer \|\| comparer);`
`843`	`843`	`}`
`844`	`844`
`845`		`- export function arrayIsEqualTo<T>(array1: ReadonlyArray<T> \| undefined, array2: ReadonlyArray<T> \| undefined, equalityComparer: (a: T, b: T) => boolean = equateValues): boolean {`
	`845`	`+ export function arrayIsEqualTo<T>(array1: ReadonlyArray<T> \| undefined, array2: ReadonlyArray<T> \| undefined, equalityComparer: (a: T, b: T, index: number) => boolean = equateValues): boolean {`
`846`	`846`	`if (!array1 \|\| !array2) {`
`847`	`847`	`return array1 === array2;`
`848`	`848`	`}`
`@@ -852,7 +852,7 @@ namespace ts {`
`852`	`852`	`}`
`853`	`853`
`854`	`854`	`for (let i = 0; i < array1.length; i++) {`
`855`		`- if (!equalityComparer(array1[i], array2[i])) {`
	`855`	`+ if (!equalityComparer(array1[i], array2[i], i)) {`
`856`	`856`	`return false;`
`857`	`857`	`}`
`858`	`858`	`}`
Original file line number	Diff line number	Diff line change
`@@ -285,16 +285,17 @@ namespace ts {`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`function getOutFileOutputs(project: ParsedCommandLine): ReadonlyArray<string> {`
`288`		`- if (!project.options.outFile) {`
	`288`	`+ const out = project.options.outFile \|\| project.options.out;`
	`289`	`+ if (!out) {`
`289`	`290`	`return Debug.fail("outFile must be set");`
`290`	`291`	`}`
`291`	`292`	`const outputs: string[] = [];`
`292`		`- outputs.push(project.options.outFile);`
	`293`	`+ outputs.push(out);`
`293`	`294`	`if (project.options.sourceMap) {`
`294`		- outputs.push(`${project.options.outFile}.map`);
	`295`	+ outputs.push(`${out}.map`);
`295`	`296`	`}`
`296`	`297`	`if (getEmitDeclarations(project.options)) {`
`297`		`- const dts = changeExtension(project.options.outFile, Extension.Dts);`
	`298`	`+ const dts = changeExtension(out, Extension.Dts);`
`298`	`299`	`outputs.push(dts);`
`299`	`300`	`if (project.options.declarationMap) {`
`300`	`301`	outputs.push(`${dts}.map`);
`@@ -862,7 +863,7 @@ namespace ts {`
`862`	`863`	`if (buildProject) {`
`863`	`864`	`buildSingleInvalidatedProject(buildProject.project, buildProject.reloadLevel);`
`864`	`865`	`if (hasPendingInvalidatedProjects()) {`
`865`		`- if (!timerToBuildInvalidatedProject) {`
	`866`	`+ if (options.watch && !timerToBuildInvalidatedProject) {`
`866`	`867`	`scheduleBuildInvalidatedProject();`
`867`	`868`	`}`
`868`	`869`	`}`
`@@ -1248,7 +1249,7 @@ namespace ts {`
`1248`	`1249`	`}`
`1249`	`1250`
`1250`	`1251`	`export function getAllProjectOutputs(project: ParsedCommandLine): ReadonlyArray<string> {`
`1251`		`- if (project.options.outFile) {`
	`1252`	`+ if (project.options.outFile \|\| project.options.out) {`
`1252`	`1253`	`return getOutFileOutputs(project);`
`1253`	`1254`	`}`
`1254`	`1255`	`else {`
Original file line number	Diff line number	Diff line change
@@ -187,9 +187,10 @@ interface Array<T> {}`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`export function checkArray(caption: string, actual: ReadonlyArray<string>, expected: ReadonlyArray<string>) {`
	`190`	`+ checkMapKeys(caption, arrayToMap(actual, identity), expected);`
`190`	`191`	assert.equal(actual.length, expected.length, `${caption}: incorrect actual number of files, expected:\r\n${expected.join("\r\n")}\r\ngot: ${actual.join("\r\n")}`);
`191`	`192`	`for (const f of expected) {`
`192`		- assert.equal(true, contains(actual, f), `${caption}: expected to find ${f} in ${actual}`);
	`193`	+ assert.isTrue(contains(actual, f), `${caption}: expected to find ${f} in ${actual}`);
`193`	`194`	`}`
`194`	`195`	`}`
`195`	`196`
@@ -934,7 +935,12 @@ interface Array<T> {}`
`934`	`935`	`const folder = this.fs.get(base) as FsFolder;`
`935`	`936`	`Debug.assert(isFsFolder(folder));`
`936`	`937`
`937`		`- this.addFileOrFolderInFolder(folder, file);`
	`938`	`+ if (!this.fs.has(file.path)) {`
	`939`	`+ this.addFileOrFolderInFolder(folder, file);`
	`940`	`+ }`
	`941`	`+ else {`
	`942`	`+ this.modifyFile(path, content);`
	`943`	`+ }`
`938`	`944`	`}`
`939`	`945`
`940`	`946`	`write(message: string) {`