Allow using the default swift build task for background compilation

This is not related to background indexing, but instead the optional
background compilation feature that runs a build task on save. Essentially
when `swift.backgroundCompilation.useDefaultTask` is enabled, any `swift`
task marked as the default "build" group task will be used instead of
the Build All task. This way the whole world is not built for large projects.

Issue: #1320

Author: award999

package.json

@@ -595,7 +595,13 @@
           "swift.backgroundCompilation": {
             "type": "boolean",
             "default": false,
-            "markdownDescription": "**Experimental**: Run `swift build` in the background whenever a file is saved. It is possible the background compilation will already be running when you attempt a compile yourself, so this is disabled by default.",
+            "markdownDescription": "Run `swift build` in the background whenever a file is saved. It is possible the background compilation will already be running when you attempt a compile yourself, so this is disabled by default.",
+            "scope": "machine-overridable"
+          },
+          "swift.backgroundCompilation.useDefaultTask": {
+            "type": "boolean",
+            "default": false,
+            "markdownDescription": "Use the default build task configured using the `Tasks: Configure Default Build Task` command when executing the background compilation. `#swift.backgroundCompilation#` must be enabled.",
             "scope": "machine-overridable"
           },
           "swift.actionAfterBuildError": {

src/BackgroundCompilation.ts

@@ -86,7 +86,7 @@ export class BackgroundCompilation implements vscode.Disposable {
      */
     async runTask() {
         // create compile task and execute it
-        const backgroundTask = await getBuildAllTask(this.folderContext);
+        const backgroundTask = await this.getTask();
         if (!backgroundTask) {
             return;
         }
@@ -96,4 +96,16 @@ export class BackgroundCompilation implements vscode.Disposable {
             // can ignore if running task fails
         }
     }
+
+    async getTask(): Promise<vscode.Task> {
+        if (!configuration.useDefaultTask) {
+            return await getBuildAllTask(this.folderContext);
+        }
+
+        const tasks = await vscode.tasks.fetchTasks({ type: "swift" });
+        const defaultTask = tasks.find(
+            t => t.group?.id === vscode.TaskGroup.Build.id && t.group?.isDefault
+        );
+        return defaultTask || (await getBuildAllTask(this.folderContext));
+    }
 }

src/configuration.ts

@@ -419,6 +419,12 @@ const configuration = {
             .getConfiguration("swift")
             .get<boolean>("backgroundCompilation", false);
     },
+    /** use the default `swift` build task when background compilation is enabled */
+    get useDefaultTask(): boolean {
+        return vscode.workspace
+            .getConfiguration("swift.backgroundCompilation")
+            .get<boolean>("useDefaultTask", false);
+    },
     /** background indexing */
     get backgroundIndexing(): "on" | "off" | "auto" {
         const value = vscode.workspace

test/integration-tests/BackgroundCompilation.test.ts

@@ -11,26 +11,39 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 //===----------------------------------------------------------------------===//
-import * as assert from "assert";
+import { expect } from "chai";
+import { match } from "sinon";
 import * as vscode from "vscode";
 
+import { BackgroundCompilation } from "@src/BackgroundCompilation";
+import { FolderContext } from "@src/FolderContext";
 import { WorkspaceContext } from "@src/WorkspaceContext";
+import configuration from "@src/configuration";
+import { getBuildAllTask } from "@src/tasks/SwiftTaskProvider";
 
+import { mockGlobalObject, mockGlobalValue } from "../MockUtils";
 import { testAssetUri } from "../fixtures";
 import { tag } from "../tags";
 import { closeAllEditors } from "../utilities/commands";
 import { waitForNoRunningTasks } from "../utilities/tasks";
-import { activateExtensionForTest, updateSettings } from "./utilities/testutilities";
+import {
+    activateExtensionForTest,
+    folderInRootWorkspace,
+    updateSettings,
+} from "./utilities/testutilities";
 
 tag("large").suite("BackgroundCompilation Test Suite", () => {
     let subscriptions: vscode.Disposable[];
     let workspaceContext: WorkspaceContext;
+    let folderContext: FolderContext;
+    let buildAllTask: vscode.Task;
 
     activateExtensionForTest({
         async setup(ctx) {
             subscriptions = [];
             workspaceContext = ctx;
-            assert.notEqual(workspaceContext.folders.length, 0);
+            folderContext = await folderInRootWorkspace("defaultPackage", workspaceContext);
+            buildAllTask = await getBuildAllTask(folderContext);
             return await updateSettings({
                 "swift.backgroundCompilation": true,
             });
@@ -62,4 +75,65 @@ tag("large").suite("BackgroundCompilation Test Suite", () => {
         await taskStartPromise;
         await waitForNoRunningTasks();
     });
+
+    suite("getTask", () => {
+        const tasksMock = mockGlobalObject(vscode, "tasks");
+        let swiftTask: vscode.Task;
+        let nonSwiftTask: vscode.Task;
+        let backgroundConfiguration: BackgroundCompilation;
+        const useDefaultTaskConfig = mockGlobalValue(configuration, "useDefaultTask");
+
+        setup(async () => {
+            nonSwiftTask = new vscode.Task(
+                {
+                    type: "shell",
+                    args: ["./build.sh"],
+                    cwd: "defaultPackage",
+                    group: {
+                        id: "build",
+                        isDefault: true,
+                    },
+                    label: "Default build",
+                },
+                folderContext.workspaceFolder,
+                "Default build",
+                "shell"
+            );
+            swiftTask = new vscode.Task(
+                {
+                    type: "swift",
+                    args: ["build"],
+                    cwd: "defaultPackage",
+                    group: "build",
+                    label: "swift build",
+                },
+                folderContext.workspaceFolder,
+                "Swift build",
+                "swift"
+            );
+            backgroundConfiguration = new BackgroundCompilation(folderContext);
+            tasksMock.fetchTasks.resolves([nonSwiftTask, swiftTask, buildAllTask]);
+            tasksMock.fetchTasks.withArgs(match.object).resolves([swiftTask, buildAllTask]);
+            useDefaultTaskConfig.setValue(true);
+        });
+
+        teardown(() => {
+            backgroundConfiguration.dispose();
+        });
+
+        test("non-swift default task", async () => {
+            expect(await backgroundConfiguration.getTask()).to.equal(buildAllTask);
+        });
+
+        test("swift default task", async () => {
+            swiftTask.group = { id: "build", isDefault: true };
+            expect(await backgroundConfiguration.getTask()).to.equal(swiftTask);
+        });
+
+        test("don't use default task", async () => {
+            useDefaultTaskConfig.setValue(false);
+            swiftTask.group = { id: "build", isDefault: true };
+            expect(await backgroundConfiguration.getTask()).to.equal(buildAllTask);
+        });
+    });
 });