Clean resolutions from tsbuild info

sheetalkamat · sheetalkamat · commit 0279cde4a981 · 2020-10-12T14:59:56.000-07:00
diff --git a/src/compiler/tsbuildPublic.ts b/src/compiler/tsbuildPublic.ts
@@ -133,8 +133,10 @@ namespace ts {
     export interface SolutionBuilder<T extends BuilderProgram> {
         build(project?: string, cancellationToken?: CancellationToken): ExitStatus;
         clean(project?: string): ExitStatus;
+        cleanResolutions(project?: string): ExitStatus;
         buildReferences(project: string, cancellationToken?: CancellationToken): ExitStatus;
         cleanReferences(project?: string): ExitStatus;
+        cleanResolutionsOfReferences(project?: string): ExitStatus;
         getNextInvalidatedProject(cancellationToken?: CancellationToken): InvalidatedProject<T> | undefined;
 
         // Currently used for testing but can be made public if needed:
@@ -1726,6 +1728,38 @@ namespace ts {
         return ExitStatus.Success;
     }
 
+    function cleanResolutions(state: SolutionBuilderState, project?: string, onlyReferences?: boolean) {
+        const buildOrder = getBuildOrderFor(state, project, onlyReferences);
+        if (!buildOrder) return ExitStatus.InvalidProject_OutputsSkipped;
+
+        if (isCircularBuildOrder(buildOrder)) {
+            reportErrors(state, buildOrder.circularDiagnostics);
+            state.host.reportErrorSummary?.(getErrorCountForSummary(buildOrder.circularDiagnostics));
+            return ExitStatus.ProjectReferenceCycle_OutputsSkipped;
+        }
+
+        let diagnostics = 0;
+        for (const proj of buildOrder) {
+            const resolvedPath = toResolvedConfigFilePath(state, proj);
+            const parsed = parseConfigFile(state, proj, resolvedPath);
+            if (parsed) {
+                diagnostics += cleanResolutionsOfTsBuildInfoAndReportError(
+                    parsed.options,
+                    state.compilerHost,
+                    err => state.host.reportDiagnostic(err),
+                    state.writeFileName,
+                );
+            }
+            else {
+                // File has gone missing; fine to ignore here
+                reportParseConfigFileDiagnostic(state, resolvedPath);
+            }
+        }
+
+        state.host.reportErrorSummary?.(diagnostics);
+        return diagnostics ? ExitStatus.DiagnosticsPresent_OutputsGenerated : ExitStatus.Success;
+    }
+
     function invalidateProject(state: SolutionBuilderState, resolved: ResolvedConfigFilePath, reloadLevel: ConfigFileProgramReloadLevel) {
         // If host implements getParsedCommandLine, we cant get list of files from parseConfigFileHost
         if (state.host.getParsedCommandLine && reloadLevel === ConfigFileProgramReloadLevel.Partial) {
@@ -1884,8 +1918,10 @@ namespace ts {
         return {
             build: (project, cancellationToken) => build(state, project, cancellationToken),
             clean: project => clean(state, project),
+            cleanResolutions: project => cleanResolutions(state, project),
             buildReferences: (project, cancellationToken) => build(state, project, cancellationToken, /*onlyReferences*/ true),
             cleanReferences: project => clean(state, project, /*onlyReferences*/ true),
+            cleanResolutionsOfReferences: project => cleanResolutions(state, project, /*onlyReferences*/ true),
             getNextInvalidatedProject: cancellationToken => {
                 setupInitialBuild(state, cancellationToken);
                 return getNextInvalidatedProject(state, getBuildOrder(state), /*reportQueue*/ false);
diff --git a/src/compiler/watch.ts b/src/compiler/watch.ts
@@ -233,6 +233,29 @@ namespace ts {
         return ExitStatus.Success;
     }
 
+    export interface CleanResolutionsOfTsBuildInfoAndReportErrorHost extends CleanResolutionsOfTsBuildInfoHost {
+        getCurrentDirectory(): string;
+    }
+    export function cleanResolutionsOfTsBuildInfoAndReportError(
+        options: CompilerOptions,
+        host: CleanResolutionsOfTsBuildInfoAndReportErrorHost,
+        reportDiagnostic: DiagnosticReporter,
+        writeFileName?: (s: string) => void,
+        reportSummary?: ReportEmitErrorSummary,
+    ): number {
+        const { emittedFiles, diagnostics } = cleanResolutionsOfTsBuildInfo(options, host);
+        diagnostics.forEach(reportDiagnostic);
+        if (writeFileName) {
+            const currentDir = host.getCurrentDirectory();
+            forEach(emittedFiles, file => {
+                const filepath = getNormalizedAbsolutePath(file, currentDir);
+                writeFileName(`TSFILE: ${filepath}`);
+            });
+        }
+        reportSummary?.(diagnostics.length);
+        return diagnostics.length;
+    }
+
     export const noopFileWatcher: FileWatcher = { close: noop };
     export const returnNoopFileWatcher = () => noopFileWatcher;
 
diff --git a/src/compiler/watchPublic.ts b/src/compiler/watchPublic.ts
@@ -16,6 +16,32 @@ namespace ts {
         return createBuildProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host);
     }
 
+    export interface CleanResolutionsOfTsBuildInfoHost {
+        readFile(fileName: string): string | undefined;
+        writeFile: WriteFileCallback;
+    }
+    export function cleanResolutionsOfTsBuildInfo(compilerOptions: CompilerOptions, host: CleanResolutionsOfTsBuildInfoHost): EmitResult {
+        if (outFile(compilerOptions)) return emitSkippedWithNoDiagnostics;
+        const buildInfoPath = getTsBuildInfoEmitOutputFilePath(compilerOptions);
+        if (!buildInfoPath) return emitSkippedWithNoDiagnostics;
+        const content = host.readFile(buildInfoPath);
+        if (!content) return emitSkippedWithNoDiagnostics;
+        const buildInfo = getBuildInfo(content);
+        if (buildInfo.version !== version) return emitSkippedWithNoDiagnostics;
+        if (!buildInfo.program) return emitSkippedWithNoDiagnostics;
+        // TODO:: Clean the actual program
+        let newContent = content;
+
+        // Actual writeFile with new program
+        const emitDiagnostics = createDiagnosticCollection();
+        writeFile(host, emitDiagnostics, buildInfoPath, newContent, /*writeByteOrderMark*/ false);
+        return {
+            emitSkipped: false,
+            diagnostics: emitDiagnostics.getDiagnostics(),
+            emittedFiles: compilerOptions.listEmittedFiles ? [buildInfoPath] : undefined
+        };
+    }
+
     export function createIncrementalCompilerHost(options: CompilerOptions, system = sys): CompilerHost {
         const host = createCompilerHostWorker(options, /*setParentNodes*/ undefined, system);
         host.createHash = maybeBind(system, system.createHash);
diff --git a/src/executeCommandLine/executeCommandLine.ts b/src/executeCommandLine/executeCommandLine.ts
@@ -261,6 +261,10 @@ namespace ts {
                 reportDiagnostic,
                 configParseResult.options
             );
+            if (commandLineOptions.cleanResolutions) {
+                configParseResult.errors.forEach(reportDiagnostic);
+                return cleanResolutions(sys, configParseResult.options, reportDiagnostic);
+            }
             if (isWatchSet(configParseResult.options)) {
                 if (reportWatchModeWithoutSysSupport(sys, reportDiagnostic)) return;
                 return createWatchOfConfigFile(
@@ -300,6 +304,9 @@ namespace ts {
                 reportDiagnostic,
                 commandLineOptions
             );
+            if (commandLineOptions.cleanResolutions) {
+                return cleanResolutions(sys, commandLineOptions, reportDiagnostic);
+            }
             if (isWatchSet(commandLineOptions)) {
                 if (reportWatchModeWithoutSysSupport(sys, reportDiagnostic)) return;
                 return createWatchOfFilesAndCompilerOptions(
@@ -431,6 +438,19 @@ namespace ts {
             return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
         }
 
+        if (buildOptions.cleanResolutions) {
+            const buildHost = createSolutionBuilderHost(
+                sys,
+                /*createProgram*/ undefined,
+                reportDiagnostic,
+                createBuilderStatusReporter(sys, shouldBePretty(sys, buildOptions)),
+                createReportErrorSummary(sys, buildOptions)
+            );
+            updateSolutionBuilderHost(sys, cb, buildHost);
+            const builder = createSolutionBuilder(buildHost, projects, buildOptions);
+            return sys.exit(builder.cleanResolutions());
+        }
+
         if (buildOptions.watch) {
             if (reportWatchModeWithoutSysSupport(sys, reportDiagnostic)) return;
             const buildHost = createSolutionBuilderWithWatchHost(
@@ -466,6 +486,17 @@ namespace ts {
             undefined;
     }
 
+    function cleanResolutions(sys: System, options: CompilerOptions, reportDiagnostic: DiagnosticReporter) {
+        const diagnostics = cleanResolutionsOfTsBuildInfoAndReportError(
+            options,
+            sys,
+            reportDiagnostic,
+            s => sys.write(s + sys.newLine),
+            createReportErrorSummary(sys, options)
+        );
+        return sys.exit(diagnostics ? ExitStatus.DiagnosticsPresent_OutputsGenerated : ExitStatus.Success);
+    }
+
     function performCompilation(
         sys: System,
         cb: ExecuteCommandLineCallbacks,
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -4961,6 +4961,11 @@ declare namespace ts {
         readFile(fileName: string): string | undefined;
     }
     function readBuilderProgram(compilerOptions: CompilerOptions, host: ReadBuildProgramHost): EmitAndSemanticDiagnosticsBuilderProgram | undefined;
+    interface CleanResolutionsOfTsBuildInfoHost {
+        readFile(fileName: string): string | undefined;
+        writeFile: WriteFileCallback;
+    }
+    function cleanResolutionsOfTsBuildInfo(compilerOptions: CompilerOptions, host: CleanResolutionsOfTsBuildInfoHost): EmitResult;
     function createIncrementalCompilerHost(options: CompilerOptions, system?: System): CompilerHost;
     interface IncrementalProgramOptions<T extends BuilderProgram> {
         rootNames: readonly string[];
@@ -5125,8 +5130,10 @@ declare namespace ts {
     interface SolutionBuilder<T extends BuilderProgram> {
         build(project?: string, cancellationToken?: CancellationToken): ExitStatus;
         clean(project?: string): ExitStatus;
+        cleanResolutions(project?: string): ExitStatus;
         buildReferences(project: string, cancellationToken?: CancellationToken): ExitStatus;
         cleanReferences(project?: string): ExitStatus;
+        cleanResolutionsOfReferences(project?: string): ExitStatus;
         getNextInvalidatedProject(cancellationToken?: CancellationToken): InvalidatedProject<T> | undefined;
     }
     /**
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -4961,6 +4961,11 @@ declare namespace ts {
         readFile(fileName: string): string | undefined;
     }
     function readBuilderProgram(compilerOptions: CompilerOptions, host: ReadBuildProgramHost): EmitAndSemanticDiagnosticsBuilderProgram | undefined;
+    interface CleanResolutionsOfTsBuildInfoHost {
+        readFile(fileName: string): string | undefined;
+        writeFile: WriteFileCallback;
+    }
+    function cleanResolutionsOfTsBuildInfo(compilerOptions: CompilerOptions, host: CleanResolutionsOfTsBuildInfoHost): EmitResult;
     function createIncrementalCompilerHost(options: CompilerOptions, system?: System): CompilerHost;
     interface IncrementalProgramOptions<T extends BuilderProgram> {
         rootNames: readonly string[];
@@ -5125,8 +5130,10 @@ declare namespace ts {
     interface SolutionBuilder<T extends BuilderProgram> {
         build(project?: string, cancellationToken?: CancellationToken): ExitStatus;
         clean(project?: string): ExitStatus;
+        cleanResolutions(project?: string): ExitStatus;
         buildReferences(project: string, cancellationToken?: CancellationToken): ExitStatus;
         cleanReferences(project?: string): ExitStatus;
+        cleanResolutionsOfReferences(project?: string): ExitStatus;
         getNextInvalidatedProject(cancellationToken?: CancellationToken): InvalidatedProject<T> | undefined;
     }
     /**
