Fix Swift Scripts without a containing folder (#1832)

* Fix Swift Scripts without a containing folder

If the user tried to run a Swift file without having opened a folder
first, the script wouldn't run.

Allow the script to run without a focused folder.

Author: plemarquand

CHANGELOG.md

@@ -14,6 +14,7 @@
 - Don't start debugging XCTest cases if the swift-testing debug session was stopped ([#1797](https://github.com/swiftlang/vscode-swift/pull/1797))
 - Improve error handling when the swift path is misconfigured ([#1801](https://github.com/swiftlang/vscode-swift/pull/1801))
 - Fix an error when performing "Run/Debug Tests Multiple Times" on Linux ([#1824](https://github.com/swiftlang/vscode-swift/pull/1824))
+- Fix the `> Swift: Run Swift Script` command not running unless a Swift Package folder is open ([#1832](https://github.com/swiftlang/vscode-swift/pull/1832))
 
 ## 2.11.20250806 - 2025-08-06
 

assets/test/scripts/SwiftScript.swift

@@ -0,0 +1 @@
+print("Hello World")

package.json

@@ -495,7 +495,6 @@
               "Use Swift 5 when running Swift scripts.",
               "Prompt to select the Swift version each time a script is run."
             ],
-            "default": "6",
             "markdownDescription": "The default Swift version to use when running Swift scripts.",
             "scope": "machine-overridable"
           },

src/commands.ts

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

src/commands/runSwiftScript.ts

@@ -37,14 +37,15 @@ import { TemporaryFolder } from "../utilities/tempFolder";
 export async function runSwiftScript(
     document: vscode.TextDocument,
     tasks: TaskManager,
-    toolchain: SwiftToolchain
-) {
-    const targetVersion = await targetSwiftVersion();
+    toolchain: SwiftToolchain,
+    logger?: (data: string) => void
+): Promise<number | undefined> {
+    const targetVersion = await targetSwiftVersion(toolchain);
     if (!targetVersion) {
         return;
     }
 
-    await withDocumentFile(document, async filename => {
+    return await withDocumentFile(document, async filename => {
         const runTask = createSwiftTask(
             ["-swift-version", targetVersion, filename],
             `Run ${filename}`,
@@ -55,7 +56,8 @@ export async function runSwiftScript(
             },
             toolchain
         );
-        await tasks.executeTaskAndWait(runTask);
+        runTask.execution.onDidWrite(data => logger?.(data));
+        return await tasks.executeTaskAndWait(runTask);
     });
 }
 
@@ -66,8 +68,8 @@ export async function runSwiftScript(
  *
  * @returns {Promise<string | undefined>} The selected Swift version, or undefined if no selection was made.
  */
-async function targetSwiftVersion() {
-    const defaultVersion = configuration.scriptSwiftLanguageVersion;
+async function targetSwiftVersion(toolchain: SwiftToolchain) {
+    const defaultVersion = configuration.scriptSwiftLanguageVersion(toolchain);
     if (defaultVersion === "Ask Every Run") {
         const picked = await vscode.window.showQuickPick(
             [
@@ -97,18 +99,18 @@ async function targetSwiftVersion() {
  * @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(
+async function withDocumentFile<T>(
     document: vscode.TextDocument,
-    callback: (filename: string) => Promise<void>
-) {
+    callback: (filename: string) => Promise<T>
+): Promise<T> {
     if (document.isUntitled) {
         const tmpFolder = await TemporaryFolder.create();
-        await tmpFolder.withTemporaryFile("swift", async filename => {
+        return await tmpFolder.withTemporaryFile("swift", async filename => {
             await fs.writeFile(filename, document.getText());
-            await callback(filename);
+            return await callback(filename);
         });
     } else {
         await document.save();
-        await callback(document.fileName);
+        return await callback(document.fileName);
     }
 }

src/configuration.ts

@@ -16,6 +16,7 @@ import * as path from "path";
 import * as vscode from "vscode";
 
 import { WorkspaceContext } from "./WorkspaceContext";
+import { SwiftToolchain } from "./toolchain/toolchain";
 import { showReloadExtensionNotification } from "./ui/ReloadExtension";
 
 export type DebugAdapters = "auto" | "lldb-dap" | "CodeLLDB";
@@ -352,10 +353,14 @@ const configuration = {
             .get<string[]>("buildArguments", [])
             .map(substituteVariablesInString);
     },
-    get scriptSwiftLanguageVersion(): string {
-        return vscode.workspace
+    scriptSwiftLanguageVersion(toolchain: SwiftToolchain): string {
+        const version = vscode.workspace
             .getConfiguration("swift")
-            .get<string>("scriptSwiftLanguageVersion", "6");
+            .get<string>("scriptSwiftLanguageVersion", toolchain.swiftVersion.major.toString());
+        if (version.length === 0) {
+            return toolchain.swiftVersion.major.toString();
+        }
+        return version;
     },
     /** swift package arguments */
     get packageArguments(): string[] {

test/integration-tests/commands/runSwiftScript.test.ts

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the VS Code Swift open source project
+//
+// Copyright (c) 2025 the VS Code Swift project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of VS Code Swift project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+import { expect } from "chai";
+import * as path from "path";
+import * as vscode from "vscode";
+
+import { runSwiftScript } from "@src/commands/runSwiftScript";
+import { TaskManager } from "@src/tasks/TaskManager";
+import { SwiftToolchain } from "@src/toolchain/toolchain";
+
+import { activateExtensionForSuite, findWorkspaceFolder } from "../utilities/testutilities";
+
+suite("Swift Scripts Suite", () => {
+    let document: vscode.TextDocument;
+    let tasks: TaskManager;
+    let toolchain: SwiftToolchain;
+
+    activateExtensionForSuite({
+        async setup(ctx) {
+            if (process.platform === "win32") {
+                // Swift Scripts on Windows give a JIT error in CI.
+                this.skip();
+            }
+
+            tasks = ctx.tasks;
+            toolchain = ctx.globalToolchain;
+
+            const folder = findWorkspaceFolder("scripts", ctx);
+            if (!folder) {
+                throw new Error("Could not find 'scripts' workspace folder");
+            }
+            const scriptPath = path.join(folder.folder.fsPath, "SwiftScript.swift");
+            const editor = await vscode.window.showTextDocument(vscode.Uri.file(scriptPath));
+            document = editor.document;
+        },
+        testAssets: ["scripts"],
+    });
+
+    test("Successfully runs a swift script", async () => {
+        let output = "";
+        const exitCode = await runSwiftScript(document, tasks, toolchain, data => (output += data));
+        expect(output).to.contain("Hello World");
+        expect(exitCode).to.be.equal(0);
+    });
+});

test/integration-tests/utilities/testutilities.ts

@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 import * as assert from "assert";
 import * as mocha from "mocha";
+import * as path from "path";
 import { isDeepStrictEqual } from "util";
 import * as vscode from "vscode";
 
@@ -23,6 +24,7 @@ import { Api } from "@src/extension";
 import { SwiftLogger } from "@src/logging/SwiftLogger";
 import { buildAllTaskName, resetBuildAllTaskCache } from "@src/tasks/SwiftTaskProvider";
 import { Extension } from "@src/utilities/extensions";
+import { fileExists } from "@src/utilities/filesystem";
 import { Version } from "@src/utilities/version";
 
 import { testAssetPath, testAssetUri } from "../../fixtures";
@@ -368,10 +370,17 @@ export const folderInRootWorkspace = async (
     if (!folder) {
         folder = await workspaceContext.addPackageFolder(testAssetUri(name), workspaceFolder);
     }
+
+    // Folders that aren't packages (i.e. assets/tests/scripts) wont generate build tasks.
+    if (!(await fileExists(path.join(testAssetUri(name).fsPath, "Package.swift")))) {
+        return folder;
+    }
+
     let i = 0;
     while (i++ < 5) {
         const tasks = await vscode.tasks.fetchTasks({ type: "swift" });
-        if (tasks.find(t => t.name === buildAllTaskName(folder, false))) {
+        const buildAllName = buildAllTaskName(folder, false);
+        if (tasks.find(t => t.name === buildAllName)) {
             break;
         }
         await new Promise(r => setTimeout(r, 5000));

test/unit-tests/commands/runSwiftScript.test.ts

@@ -21,13 +21,15 @@ import configuration from "@src/configuration";
 import { TaskManager } from "@src/tasks/TaskManager";
 import { BuildFlags } from "@src/toolchain/BuildFlags";
 import { SwiftToolchain } from "@src/toolchain/toolchain";
+import { Version } from "@src/utilities/version";
 
 import { instance, mockFn, mockGlobalObject, mockGlobalValue, mockObject } from "../../MockUtils";
 
 suite("runSwiftScript Test Suite", () => {
     const mockTaskManager = mockObject<TaskManager>({ executeTaskAndWait: stub().resolves() });
     const mockToolchain = mockObject<SwiftToolchain>({
         getToolchainExecutable: () => "/usr/bin/swift",
+        swiftVersion: new Version(6, 0, 0),
         buildFlags: instance(
             mockObject<BuildFlags>({
                 withAdditionalFlags: mockFn(s => s.callsFake(args => args)),
@@ -93,7 +95,7 @@ suite("runSwiftScript Test Suite", () => {
         const mockWindow = mockGlobalObject(vscode, "window");
 
         test("Executes run task with the users chosen swift version", async () => {
-            config.setValue("5");
+            config.setValue(() => "5");
 
             await runSwiftScript(
                 instance(createMockTextDocument()),
@@ -107,7 +109,7 @@ suite("runSwiftScript Test Suite", () => {
         });
 
         test("Prompts for the users desired swift version", async () => {
-            config.setValue("Ask Every Run");
+            config.setValue(() => "Ask Every Run");
             const selectedItem = { value: "6", label: "Swift 6" };
             mockWindow.showQuickPick.resolves(selectedItem);
 
@@ -123,7 +125,7 @@ suite("runSwiftScript Test Suite", () => {
         });
 
         test("Exists when the user cancels the prompt", async () => {
-            config.setValue("Ask Every Run");
+            config.setValue(() => "Ask Every Run");
             mockWindow.showQuickPick.resolves(undefined);
 
             await runSwiftScript(