Extra debug logging

Author: award999

.github/workflows/pull_request.yml

@@ -23,7 +23,6 @@ jobs:
           . .github/workflows/scripts/setup-linux.sh
           [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
           npm ci
-          npm run compile
           npm run package
           npm run preview-package
           for file in *.vsix; do
@@ -47,9 +46,7 @@ jobs:
   tests:
     name: ${{ contains(github.event.pull_request.labels.*.name, 'full-test-run') && 'Full Test Run' || 'Test'}}
     uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
-    needs: package
     with:
-      needs_token: true
       # Linux
       linux_exclude_swift_versions: '[{"swift_version": "nightly-6.1"},{"swift_version": "nightly-main"}]'
       linux_env_vars: |
@@ -64,6 +61,7 @@ jobs:
       windows_exclude_swift_versions: '[{"swift_version": "nightly-6.1"},{"swift_version": "nightly"}]'
       windows_env_vars: |
         CI=1
+        VSCODE_DEBUG=1
         FAST_TEST_RUN=${{ contains(github.event.pull_request.labels.*.name, 'full-test-run') && '0' || '1'}}
       windows_pre_build_command: .github\workflows\scripts\windows\setup.ps1
       windows_build_command: scripts\test_windows.ps1

assets/test/.vscode/settings.json

@@ -8,6 +8,5 @@
         "-DTEST_ARGUMENT_SET_VIA_TEST_BUILD_ARGUMENTS_SETTING"
     ],
     "lldb.verboseLogging": true,
-    "swift.backgroundCompilation": false,
     "swift.sourcekit-lsp.backgroundIndexing": "off"
 }

src/tasks/SwiftPluginTaskProvider.ts

@@ -96,10 +96,11 @@ export class SwiftPluginTaskProvider implements vscode.TaskProvider {
             task.scope ?? vscode.TaskScope.Workspace,
             task.name,
             "swift-plugin",
-            new SwiftExecution(swift, swiftArgs, {
-                cwd,
-                presentation: task.presentationOptions,
-            }),
+            task.execution ??
+                new SwiftExecution(swift, swiftArgs, {
+                    cwd,
+                    presentation: task.presentationOptions,
+                }),
             task.problemMatchers
         );
         newTask.detail = task.detail ?? `swift ${swiftArgs.join(" ")}`;

test/integration-tests/DiagnosticsManager.test.ts

@@ -244,19 +244,15 @@ suite("DiagnosticsManager Test Suite", function () {
                         workspaceContext.focusFolder(null);
 
                         resetSettings = await updateSettings({ "swift.diagnosticsStyle": style });
-                        const task = await createBuildAllTask(folderContext);
-                        // This return exit code and output for the task but we will omit it here
-                        // because the failures are expected and we just want the task to build
-                        await executeTaskAndWaitForResult(task).catch(() => {
-                            /* Ignore */
-                        });
                     });
 
                     test("succeeds", async function () {
                         await Promise.all([
                             waitForDiagnostics(expected()),
                             createBuildAllTask(folderContext).then(task =>
-                                executeTaskAndWaitForResult(task)
+                                executeTaskAndWaitForResult(task).catch(() => {
+                                    /* Ignore */
+                                })
                             ),
                         ]);
                         await waitForNoRunningTasks();

test/integration-tests/SwiftSnippet.test.ts

@@ -13,7 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 import * as vscode from "vscode";
-import { testAssetPath, testAssetUri } from "../fixtures";
+import { testAssetUri } from "../fixtures";
 import { waitForNoRunningTasks } from "../utilities/tasks";
 import { expect } from "chai";
 import {
@@ -22,19 +22,14 @@ import {
     waitUntilDebugSessionTerminates,
 } from "../utilities/debug";
 import { Version } from "../../src/utilities/version";
-import { activateExtensionForSuite, folderInRootWorkspace } from "./utilities/testutilities";
+import {
+    activateExtensionForSuite,
+    folderInRootWorkspace,
+    updateSettings,
+} from "./utilities/testutilities";
 import { WorkspaceContext } from "../../src/WorkspaceContext";
-import { join } from "path";
 import { closeAllEditors } from "../utilities/commands";
-
-function normalizePath(...segments: string[]): string {
-    let path = join(...segments);
-    if (process.platform === "win32") {
-        path = path.endsWith(".exe") ? path : path + ".exe";
-        path = path.replace(/\//g, "\\");
-    }
-    return path.toLocaleLowerCase(); // Windows may use d:\ or D:\
-}
+import { Commands } from "../../src/commands";
 
 suite("SwiftSnippet Test Suite @slow", function () {
     this.timeout(180000);
@@ -44,20 +39,24 @@ suite("SwiftSnippet Test Suite @slow", function () {
         new vscode.SourceBreakpoint(new vscode.Location(uri, new vscode.Position(2, 0))),
     ];
     let workspaceContext: WorkspaceContext;
+    let resetSettings: (() => Promise<void>) | undefined;
 
     activateExtensionForSuite({
         async setup(ctx) {
             workspaceContext = ctx;
 
             const folder = await folderInRootWorkspace("defaultPackage", workspaceContext);
-            if (folder.toolchain.swiftVersion.isLessThan(new Version(5, 9, 0))) {
+            if (folder.toolchain.swiftVersion.isLessThan(new Version(5, 10, 0))) {
                 this.skip();
             }
+            resetSettings = await updateSettings({
+                "swift.debugger.debugAdapter": "lldb-dap",
+            });
             await waitForNoRunningTasks();
 
             // File needs to be open for command to be enabled
-            const doc = await vscode.workspace.openTextDocument(uri.fsPath);
-            await vscode.window.showTextDocument(doc);
+            await workspaceContext.focusFolder(folder);
+            await vscode.window.showTextDocument(uri);
 
             // Set a breakpoint
             vscode.debug.addBreakpoints(breakpoints);
@@ -66,19 +65,24 @@ suite("SwiftSnippet Test Suite @slow", function () {
     });
 
     suiteTeardown(async () => {
-        closeAllEditors();
+        await closeAllEditors();
         vscode.debug.removeBreakpoints(breakpoints);
+        if (resetSettings) {
+            await resetSettings();
+        }
     });
 
     test("Run `Swift: Run Swift Snippet` command for snippet file", async () => {
         const sessionPromise = waitUntilDebugSessionTerminates("Run hello");
 
-        const succeeded = await vscode.commands.executeCommand("swift.runSnippet");
+        const succeeded = await vscode.commands.executeCommand(Commands.RUN_SNIPPET, "hello");
 
         expect(succeeded).to.be.true;
         const session = await sessionPromise;
-        expect(normalizePath(session.configuration.program)).to.equal(
-            normalizePath(testAssetPath("defaultPackage"), ".build", "debug", "hello")
+        expect(vscode.Uri.file(session.configuration.program).fsPath).to.equal(
+            testAssetUri(
+                "defaultPackage/.build/debug/hello" + (process.platform === "win32" ? ".exe" : "")
+            ).fsPath
         );
         expect(session.configuration).to.have.property("noDebug", true);
     });
@@ -91,16 +95,33 @@ suite("SwiftSnippet Test Suite @slow", function () {
         );
         const sessionPromise = waitUntilDebugSessionTerminates("Run hello");
 
-        const succeeded = vscode.commands.executeCommand("swift.debugSnippet");
+        const succeededPromise: Thenable<boolean> = vscode.commands.executeCommand(
+            Commands.DEBUG_SNIPPET,
+            "hello"
+        );
 
         // Once bp is hit, continue
-        await bpPromise.then(() => continueSession());
+        await bpPromise;
+        let succeeded = false;
+        succeededPromise.then(s => (succeeded = s));
+        while (!succeeded) {
+            console.log("here continue");
+            try {
+                await continueSession();
+            } catch {
+                // Ignore
+            }
+            console.log("here continued");
+            await new Promise(r => setTimeout(r, 500));
+        }
 
-        await expect(succeeded).to.eventually.be.true;
+        expect(succeeded).to.be.true;
 
         const session = await sessionPromise;
-        expect(normalizePath(session.configuration.program)).to.equal(
-            normalizePath(testAssetPath("defaultPackage"), ".build", "debug", "hello")
+        expect(vscode.Uri.file(session.configuration.program).fsPath).to.equal(
+            testAssetUri(
+                "defaultPackage/.build/debug/hello" + (process.platform === "win32" ? ".exe" : "")
+            ).fsPath
         );
         expect(session.configuration).to.not.have.property("noDebug");
     });

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

@@ -21,7 +21,6 @@ import { testAssetUri } from "../../fixtures";
 import { FolderContext } from "../../../src/FolderContext";
 import { WorkspaceContext } from "../../../src/WorkspaceContext";
 import { Commands } from "../../../src/commands";
-import { Workbench } from "../../../src/utilities/commands";
 import { continueSession, waitForDebugAdapterRequest } from "../../utilities/debug";
 import { activateExtensionForSuite, folderInRootWorkspace } from "../utilities/testutilities";
 import { Version } from "../../../src/utilities/version";
@@ -42,52 +41,35 @@ suite("Build Commands @slow", function () {
             // The description of this package is crashing on Windows with Swift 5.9.x and below
             if (
                 process.platform === "win32" &&
-                ctx.globalToolchain.swiftVersion.isLessThanOrEqual(new Version(5, 9, 0))
+                ctx.globalToolchain.swiftVersion.isLessThan(new Version(5, 10, 0))
             ) {
                 this.skip();
             }
+            // A breakpoint will have not effect on the Run command.
+            vscode.debug.addBreakpoints(breakpoints);
 
             workspaceContext = ctx;
             await waitForNoRunningTasks();
             folderContext = await folderInRootWorkspace("defaultPackage", workspaceContext);
             await workspaceContext.focusFolder(folderContext);
-            await vscode.tasks.fetchTasks({ type: "swift" });
-            await vscode.window.showTextDocument(uri);
-        },
-        async teardown() {
-            await vscode.commands.executeCommand(Workbench.ACTION_CLOSEALLEDITORS);
+            const tasks = await vscode.tasks.fetchTasks({ type: "swift" });
+            tasks.forEach(t =>
+                console.log("Label: " + t.definition.label + " => " + JSON.stringify(t.definition))
+            );
         },
         requiresDebugger: true,
     });
 
-    test("Swift: Run Build", async () => {
-        // A breakpoint will have not effect on the Run command.
-        vscode.debug.addBreakpoints(breakpoints);
-
-        const result = await vscode.commands.executeCommand(Commands.RUN);
-        expect(result).to.be.true;
-
+    suiteTeardown(async () => {
         vscode.debug.removeBreakpoints(breakpoints);
     });
 
-    test("Swift: Clean Build", async () => {
-        let result = await vscode.commands.executeCommand(Commands.RUN);
-        expect(result).to.be.true;
-
-        const buildPath = path.join(folderContext.folder.fsPath, ".build");
-        const beforeItemCount = (await fs.readdir(buildPath)).length;
-
-        result = await vscode.commands.executeCommand(Commands.CLEAN_BUILD);
+    test("Swift: Run Build", async () => {
+        const result = await vscode.commands.executeCommand(Commands.RUN, "PackageExe");
         expect(result).to.be.true;
-
-        const afterItemCount = (await fs.readdir(buildPath)).length;
-        // .build folder is going to be filled with built artifacts after Commands.RUN command
-        // After executing the clean command the build directory is guranteed to have less entry.
-        expect(afterItemCount).to.be.lessThan(beforeItemCount);
     });
 
     test("Swift: Debug Build", async () => {
-        vscode.debug.addBreakpoints(breakpoints);
         // Promise used to indicate we hit the break point.
         // NB: "stopped" is the exact command when debuggee has stopped due to break point,
         // but "stackTrace" is the deterministic sync point we will use to make sure we can execute continue
@@ -97,12 +79,34 @@ suite("Build Commands @slow", function () {
             "stackTrace"
         );
 
-        const result = vscode.commands.executeCommand(Commands.DEBUG);
-        expect(result).to.eventually.be.true;
+        const resultPromise: Thenable<boolean> = vscode.commands.executeCommand(
+            Commands.DEBUG,
+            "PackageExe"
+        );
 
         await bpPromise;
-        await continueSession();
+        let succeeded = false;
+        resultPromise.then(s => (succeeded = s));
+        while (!succeeded) {
+            await continueSession();
+            await new Promise(r => setTimeout(r, 500));
+        }
+        await expect(resultPromise).to.eventually.be.true;
+    });
 
-        vscode.debug.removeBreakpoints(breakpoints);
+    test("Swift: Clean Build", async () => {
+        let result = await vscode.commands.executeCommand(Commands.RUN, "PackageExe");
+        expect(result).to.be.true;
+
+        const buildPath = path.join(folderContext.folder.fsPath, ".build");
+        const beforeItemCount = (await fs.readdir(buildPath)).length;
+
+        result = await vscode.commands.executeCommand(Commands.CLEAN_BUILD);
+        expect(result).to.be.true;
+
+        const afterItemCount = (await fs.readdir(buildPath)).length;
+        // .build folder is going to be filled with built artifacts after Commands.RUN command
+        // After executing the clean command the build directory is guranteed to have less entry.
+        expect(afterItemCount).to.be.lessThan(beforeItemCount);
     });
 });

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

@@ -21,7 +21,7 @@ import { WorkspaceContext } from "../../../src/WorkspaceContext";
 import { Commands } from "../../../src/commands";
 import { activateExtensionForSuite, folderInRootWorkspace } from "../utilities/testutilities";
 import { executeTaskAndWaitForResult, waitForNoRunningTasks } from "../../utilities/tasks";
-import { getBuildAllTask, SwiftTask } from "../../../src/tasks/SwiftTaskProvider";
+import { createBuildAllTask } from "../../../src/tasks/SwiftTaskProvider";
 
 suite("Dependency Commmands Test Suite", function () {
     // full workflow's interaction with spm is longer than the default timeout
@@ -58,7 +58,7 @@ suite("Dependency Commmands Test Suite", function () {
 
         setup(async () => {
             await workspaceContext.focusFolder(depsContext);
-            await executeTaskAndWaitForResult((await getBuildAllTask(depsContext)) as SwiftTask);
+            await executeTaskAndWaitForResult(await createBuildAllTask(depsContext));
             treeProvider = new ProjectPanelProvider(workspaceContext);
         });
 

test/integration-tests/language/LanguageClientIntegration.test.ts

@@ -19,15 +19,15 @@ import { LanguageClientManager } from "../../../src/sourcekit-lsp/LanguageClient
 import { WorkspaceContext } from "../../../src/WorkspaceContext";
 import { testAssetUri } from "../../fixtures";
 import { executeTaskAndWaitForResult, waitForNoRunningTasks } from "../../utilities/tasks";
-import { getBuildAllTask, SwiftTask } from "../../../src/tasks/SwiftTaskProvider";
+import { createBuildAllTask } from "../../../src/tasks/SwiftTaskProvider";
 import { activateExtensionForSuite, folderInRootWorkspace } from "../utilities/testutilities";
 import { waitForClientState, waitForIndex } from "../utilities/lsputilities";
 import { FolderContext } from "../../../src/FolderContext";
 
 async function buildProject(ctx: WorkspaceContext, name: string) {
     await waitForNoRunningTasks();
     const folderContext = await folderInRootWorkspace(name, ctx);
-    const task = (await getBuildAllTask(folderContext)) as SwiftTask;
+    const task = await createBuildAllTask(folderContext);
     const { exitCode, output } = await executeTaskAndWaitForResult(task);
     expect(exitCode, `${output}`).to.equal(0);
     return folderContext;

test/integration-tests/tasks/SwiftPluginTaskProvider.test.ts

@@ -28,6 +28,7 @@ import {
     cleanOutput,
     executeTaskAndWaitForResult,
     waitForEndTaskProcess,
+    waitForNoRunningTasks,
 } from "../../utilities/tasks";
 import { mutable } from "../../utilities/types";
 import { SwiftExecution } from "../../../src/tasks/SwiftExecution";
@@ -165,6 +166,7 @@ suite("SwiftPluginTaskProvider Test Suite", function () {
         suite(name, () => {
             let resetSettings: (() => Promise<void>) | undefined;
             beforeEach(async function () {
+                await waitForNoRunningTasks();
                 resetSettings = await updateSettings(settings);
             });
 
@@ -198,21 +200,18 @@ suite("SwiftPluginTaskProvider Test Suite", function () {
         suite("createSwiftPluginTask", () => {
             let taskProvider: SwiftPluginTaskProvider;
 
-            setup(() => {
+            beforeEach(async () => {
                 taskProvider = workspaceContext.pluginProvider;
+                await waitForNoRunningTasks();
             });
 
             test("Exit code on success", async () => {
-                const task = taskProvider.createSwiftPluginTask(
-                    folderContext.swiftPackage.plugins[0],
-                    folderContext.toolchain,
-                    {
-                        cwd: folderContext.folder,
-                        scope: folderContext.workspaceFolder,
-                    }
-                );
+                const task = (
+                    await vscode.tasks.fetchTasks({ type: "swift-plugin " })
+                )[0] as SwiftTask;
                 const { exitCode, output } = await executeTaskAndWaitForResult(task);
-                expect(exitCode).to.equal(0);
+                expect(exitCode, output).to.equal(0);
+                console.log("output: " + output);
                 expect(cleanOutput(output)).to.include("Hello, World!");
             });