Remove temp folder from WorkspaceContext (#1781)

* Remove temp folder from WorkspaceContext

In an effort to pair down WorkspaceContext and the dependencies that
need to be threaded through the application from it, remove the common
tempFolder from it and grab a reference to it as needed.

A large portion of this PR is refactoring the `runScript` commandand
ensuring nothing broke by adding tests.

Author: plemarquand

src/TestExplorer/TestRunner.ts

@@ -981,7 +981,8 @@ export class TestRunner {
         testBuildConfig: vscode.DebugConfiguration,
         runState: TestRunnerTestRunState
     ) {
-        await this.workspaceContext.tempFolder.withTemporaryFile("xml", async filename => {
+        const tempFolder = await TemporaryFolder.create();
+        await tempFolder.withTemporaryFile("xml", async filename => {
             const args = [...(testBuildConfig.args ?? []), "--xunit-output", filename];
 
             try {

src/WorkspaceContext.ts

@@ -19,7 +19,6 @@ import { StatusItem } from "./ui/StatusItem";
 import { swiftLibraryPathKey } from "./utilities/utilities";
 import { isExcluded, isPathInsidePath } from "./utilities/filesystem";
 import { LanguageClientToolchainCoordinator } from "./sourcekit-lsp/LanguageClientToolchainCoordinator";
-import { TemporaryFolder } from "./utilities/tempFolder";
 import { TaskManager } from "./tasks/TaskManager";
 import { makeDebugConfigurations } from "./debugger/launch";
 import configuration from "./configuration";
@@ -76,9 +75,8 @@ export class WorkspaceContext implements vscode.Disposable {
 
     public loggerFactory: SwiftLoggerFactory;
 
-    private constructor(
+    constructor(
         extensionContext: vscode.ExtensionContext,
-        public tempFolder: TemporaryFolder,
         public logger: SwiftLogger,
         public globalToolchain: SwiftToolchain
     ) {
@@ -230,16 +228,6 @@ export class WorkspaceContext implements vscode.Disposable {
         return this.globalToolchain.swiftVersion;
     }
 
-    /** Get swift version and create WorkspaceContext */
-    static async create(
-        extensionContext: vscode.ExtensionContext,
-        logger: SwiftLogger,
-        toolchain: SwiftToolchain
-    ): Promise<WorkspaceContext> {
-        const tempFolder = await TemporaryFolder.create();
-        return new WorkspaceContext(extensionContext, tempFolder, logger, toolchain);
-    }
-
     /**
      * Update context keys based on package contents
      */

src/commands.ts

@@ -213,7 +213,15 @@ export function register(ctx: WorkspaceContext): vscode.Disposable[] {
             Commands.RESET_PACKAGE,
             async (_ /* Ignore context */, folder) => await resetPackage(ctx, folder)
         ),
-        vscode.commands.registerCommand("swift.runScript", async () => await runSwiftScript(ctx)),
+        vscode.commands.registerCommand("swift.runScript", async () => {
+            if (ctx.currentFolder && vscode.window.activeTextEditor?.document) {
+                await runSwiftScript(
+                    vscode.window.activeTextEditor.document,
+                    ctx.tasks,
+                    ctx.currentFolder.toolchain
+                );
+            }
+        }),
         vscode.commands.registerCommand("swift.openPackage", async () => {
             if (ctx.currentFolder) {
                 return await openPackage(ctx.currentFolder.swiftVersion, ctx.currentFolder.folder);

src/commands/runSwiftScript.ts

@@ -15,38 +15,58 @@
 import * as vscode from "vscode";
 import * as path from "path";
 import * as fs from "fs/promises";
-import { createSwiftTask } from "../tasks/SwiftTaskProvider";
-import { WorkspaceContext } from "../WorkspaceContext";
-import { Version } from "../utilities/version";
 import configuration from "../configuration";
+import { createSwiftTask } from "../tasks/SwiftTaskProvider";
+import { TemporaryFolder } from "../utilities/tempFolder";
+import { TaskManager } from "../tasks/TaskManager";
+import { SwiftToolchain } from "../toolchain/toolchain";
 
 /**
- * Run the active document through the Swift REPL
+ * Runs the Swift code in the supplied document.
+ *
+ * This function checks for a valid document and Swift version, then creates and executes
+ * a Swift task to run the script file. The task is configured to always reveal its output
+ * and clear previous output. The working directory is set to the script's location.
+ *
+ * @param document - The text document containing the Swift script to run. If undefined, the function returns early.
+ * @param tasks - The TaskManager instance used to execute and manage the Swift task.
+ * @param toolchain - The SwiftToolchain to use for running the script.
+ * @returns A promise that resolves when the script has finished running, or returns early if the user is prompted
+ * for which swift version to use and they exit the dialog without choosing one.
  */
-export async function runSwiftScript(ctx: WorkspaceContext) {
-    const document = vscode.window.activeTextEditor?.document;
-    if (!document) {
-        return;
-    }
-
-    if (!ctx.currentFolder) {
+export async function runSwiftScript(
+    document: vscode.TextDocument,
+    tasks: TaskManager,
+    toolchain: SwiftToolchain
+) {
+    const targetVersion = await targetSwiftVersion();
+    if (!targetVersion) {
         return;
     }
 
-    // Swift scripts require new swift driver to work on Windows. Swift driver is available
-    // from v5.7 of Windows Swift
-    if (
-        process.platform === "win32" &&
-        ctx.currentFolder.swiftVersion.isLessThan(new Version(5, 7, 0))
-    ) {
-        void vscode.window.showErrorMessage(
-            "Run Swift Script is unavailable with the legacy driver on Windows."
+    await withDocumentFile(document, async filename => {
+        const runTask = createSwiftTask(
+            ["-swift-version", targetVersion, filename],
+            `Run ${filename}`,
+            {
+                scope: vscode.TaskScope.Global,
+                cwd: vscode.Uri.file(path.dirname(filename)),
+                presentationOptions: { reveal: vscode.TaskRevealKind.Always, clear: true },
+            },
+            toolchain
         );
-        return;
-    }
-
-    let target: string;
+        await tasks.executeTaskAndWait(runTask);
+    });
+}
 
+/**
+ * Determines the target Swift language version to use for script execution.
+ * If the configuration is set to "Ask Every Run", prompts the user to select a version.
+ * Otherwise, returns the default version from the user's settings.
+ *
+ * @returns {Promise<string | undefined>} The selected Swift version, or undefined if no selection was made.
+ */
+async function targetSwiftVersion() {
     const defaultVersion = configuration.scriptSwiftLanguageVersion;
     if (defaultVersion === "Ask Every Run") {
         const picked = await vscode.window.showQuickPick(
@@ -59,41 +79,36 @@ export async function runSwiftScript(ctx: WorkspaceContext) {
                 placeHolder: "Select a target Swift version",
             }
         );
-
-        if (!picked) {
-            return;
-        }
-        target = picked.value;
+        return picked?.value;
     } else {
-        target = defaultVersion;
+        return defaultVersion;
     }
+}
 
-    let filename = document.fileName;
-    let isTempFile = false;
+/**
+ * Executes a callback with the filename of the given `vscode.TextDocument`.
+ * If the document is untitled (not yet saved to disk), it creates a temporary file,
+ * writes the document's content to it, and passes its filename to the callback.
+ * Otherwise, it ensures the document is saved and passes its actual filename.
+ *
+ * The temporary file is automatically deleted when the callback completes.
+ *
+ * @param document - The VSCode text document to operate on.
+ * @param callback - An async function that receives the filename of the document or temporary file.
+ * @returns A promise that resolves when the callback has completed.
+ */
+async function withDocumentFile(
+    document: vscode.TextDocument,
+    callback: (filename: string) => Promise<void>
+) {
     if (document.isUntitled) {
-        // if document hasn't been saved, save it to a temporary file
-        isTempFile = true;
-        filename = ctx.tempFolder.filename(document.fileName, "swift");
-        const text = document.getText();
-        await fs.writeFile(filename, text);
+        const tmpFolder = await TemporaryFolder.create();
+        await tmpFolder.withTemporaryFile("swift", async filename => {
+            await fs.writeFile(filename, document.getText());
+            await callback(filename);
+        });
     } else {
-        // otherwise save document
         await document.save();
-    }
-    const runTask = createSwiftTask(
-        ["-swift-version", target, filename],
-        `Run ${filename}`,
-        {
-            scope: vscode.TaskScope.Global,
-            cwd: vscode.Uri.file(path.dirname(filename)),
-            presentationOptions: { reveal: vscode.TaskRevealKind.Always, clear: true },
-        },
-        ctx.currentFolder.toolchain
-    );
-    await ctx.tasks.executeTaskAndWait(runTask);
-
-    // delete file after running swift
-    if (isTempFile) {
-        await fs.rm(filename);
+        await callback(document.fileName);
     }
 }

src/coverage/LcovResults.ts

@@ -23,7 +23,7 @@ import { FolderContext } from "../FolderContext";
 import { execFileStreamOutput } from "../utilities/utilities";
 import { BuildFlags } from "../toolchain/BuildFlags";
 import { TestLibrary } from "../TestExplorer/TestRunner";
-import { DisposableFileCollection } from "../utilities/tempFolder";
+import { DisposableFileCollection, TemporaryFolder } from "../utilities/tempFolder";
 import { TargetType } from "../SwiftPackage";
 import { TestingConfigurationFactory } from "../debugger/buildConfig";
 import { TestKind } from "../TestExplorer/TestKind";
@@ -35,13 +35,11 @@ interface CodeCovFile {
 
 export class TestCoverage {
     private lcovFiles: CodeCovFile[] = [];
-    private lcovTmpFiles: DisposableFileCollection;
+    private _lcovTmpFiles?: DisposableFileCollection;
+    private _lcovTmpFilesInit?: Promise<DisposableFileCollection>;
     private coverageDetails = new Map<vscode.Uri, vscode.FileCoverageDetail[]>();
 
-    constructor(private folderContext: FolderContext) {
-        const tmpFolder = folderContext.workspaceContext.tempFolder;
-        this.lcovTmpFiles = tmpFolder.createDisposableFileCollection();
-    }
+    constructor(private folderContext: FolderContext) {}
 
     /**
      * Returns coverage information for the suppplied URI.
@@ -60,7 +58,7 @@ export class TestCoverage {
             true
         );
         const result = await asyncfs.readFile(`${buildDirectory}/debug/codecov/default.profdata`);
-        const filename = this.lcovTmpFiles.file(testLibrary, "profdata");
+        const filename = (await this.lcovTmpFiles()).file(testLibrary, "profdata");
         await asyncfs.writeFile(filename, result);
         this.lcovFiles.push({ testLibrary, path: filename });
     }
@@ -88,14 +86,14 @@ export class TestCoverage {
                 this.coverageDetails.set(uri, detailedCoverage);
             }
         }
-        await this.lcovTmpFiles.dispose();
+        await this._lcovTmpFiles?.dispose();
     }
 
     /**
      * Merges multiple `.profdata` files into a single `.profdata` file.
      */
     private async mergeProfdata(profDataFiles: string[]) {
-        const filename = this.lcovTmpFiles.file("merged", "profdata");
+        const filename = (await this.lcovTmpFiles()).file("merged", "profdata");
         const toolchain = this.folderContext.toolchain;
         const llvmProfdata = toolchain.getToolchainExecutable("llvm-profdata");
         await execFileStreamOutput(
@@ -196,6 +194,27 @@ export class TestCoverage {
         return buffer;
     }
 
+    /**
+     * Lazily creates (once) and returns the disposable file collection used for LCOV processing.
+     * Safe against concurrent callers.
+     */
+    private async lcovTmpFiles(): Promise<DisposableFileCollection> {
+        if (this._lcovTmpFiles) {
+            return this._lcovTmpFiles;
+        }
+
+        // Use an internal promise to avoid duplicate folder creation in concurrent calls.
+        if (!this._lcovTmpFilesInit) {
+            this._lcovTmpFilesInit = (async () => {
+                const tempFolder = await TemporaryFolder.create();
+                this._lcovTmpFiles = tempFolder.createDisposableFileCollection();
+                return this._lcovTmpFiles;
+            })();
+        }
+
+        return (await this._lcovTmpFilesInit)!;
+    }
+
     /**
      * Constructs a string containing all the paths to exclude from the code coverage report.
      * This should exclude everything in the `.build` folder as well as all the test targets.

src/extension.ts

@@ -82,7 +82,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<Api> {
             };
         }
 
-        const workspaceContext = await WorkspaceContext.create(context, logger, toolchain);
+        const workspaceContext = new WorkspaceContext(context, logger, toolchain);
         context.subscriptions.push(workspaceContext);
 
         context.subscriptions.push(new SwiftEnvironmentVariablesManager(context));