Move setting from backgroundCompilation subsection

- Setting `swift.backgroundCompilation` to `true` was causing the value
  of `swift.backgroundCompilation.useDefaultTask` to be ignored

Author: award999

CHANGELOG.md

@@ -8,7 +8,7 @@
 - Prompt to restart `SourceKit-LSP` after changing `.sourcekit-lsp/config.json` files ([#1744](https://github.com/swiftlang/vscode-swift/issues/1744))
 - Prompt to cancel and replace the active test run if one is in flight ([#1774](https://github.com/swiftlang/vscode-swift/pull/1774))
 - A walkthrough for first time extension users ([#1560](https://github.com/swiftlang/vscode-swift/issues/1560))
-- New `swift.backgroundCompilation.useDefaultTask` setting that will run the default `swift` build task on save ([#1857](https://github.com/swiftlang/vscode-swift/pull/1857))
+- New `swift.backgroundCompilationUsesDefaultTask` setting that will run the default `swift` build task on save ([#1857](https://github.com/swiftlang/vscode-swift/pull/1857))
 
 ### Fixed
 

package.json

@@ -598,7 +598,7 @@
             "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": {
+          "swift.backgroundCompilationUsesDefaultTask": {
             "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.",

src/configuration.ts

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

test/integration-tests/BackgroundCompilation.test.ts

@@ -18,121 +18,137 @@ 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 { mockGlobalObject } from "../MockUtils";
 import { testAssetUri } from "../fixtures";
 import { tag } from "../tags";
 import { closeAllEditors } from "../utilities/commands";
 import { waitForNoRunningTasks } from "../utilities/tasks";
 import {
-    activateExtensionForTest,
+    activateExtensionForSuite,
     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;
-            folderContext = await folderInRootWorkspace("defaultPackage", workspaceContext);
-            buildAllTask = await getBuildAllTask(folderContext);
-            return await updateSettings({
-                "swift.backgroundCompilation": true,
-            });
-        },
-    });
+    async function setupFolder(ctx: WorkspaceContext) {
+        workspaceContext = ctx;
+        folderContext = await folderInRootWorkspace("defaultPackage", workspaceContext);
+        buildAllTask = await getBuildAllTask(folderContext);
+    }
 
-    suiteTeardown(async () => {
-        subscriptions.forEach(s => s.dispose());
-        await closeAllEditors();
-    });
+    suite("build all on save", () => {
+        let subscriptions: vscode.Disposable[];
 
-    test("build all on save", async () => {
-        const taskStartPromise = new Promise<void>(resolve => {
-            subscriptions.push(
-                vscode.tasks.onDidStartTask(e => {
-                    const task = e.execution.task;
-                    if (task.name.includes("Build All")) {
-                        resolve();
-                    }
-                })
-            );
+        activateExtensionForSuite({
+            async setup(ctx) {
+                subscriptions = [];
+                await setupFolder(ctx);
+                return await updateSettings({
+                    "swift.backgroundCompilation": true,
+                });
+            },
         });
 
-        const uri = testAssetUri("defaultPackage/Sources/PackageExe/main.swift");
-        const doc = await vscode.workspace.openTextDocument(uri.fsPath);
-        await vscode.window.showTextDocument(doc);
-        await vscode.workspace.save(uri);
+        suiteTeardown(async () => {
+            subscriptions.forEach(s => s.dispose());
+            await closeAllEditors();
+        });
+
+        test("runs build task", async () => {
+            const taskStartPromise = new Promise<void>(resolve => {
+                subscriptions.push(
+                    vscode.tasks.onDidStartTask(e => {
+                        const task = e.execution.task;
+                        if (task.name.includes("Build All")) {
+                            resolve();
+                        }
+                    })
+                );
+            });
 
-        await taskStartPromise;
-        await waitForNoRunningTasks();
+            const uri = testAssetUri("defaultPackage/Sources/PackageExe/main.swift");
+            const doc = await vscode.workspace.openTextDocument(uri.fsPath);
+            await vscode.window.showTextDocument(doc);
+            await vscode.workspace.save(uri);
+
+            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,
+
+        activateExtensionForSuite({
+            async setup(ctx) {
+                await setupFolder(ctx);
+                nonSwiftTask = new vscode.Task(
+                    {
+                        type: "shell",
+                        args: ["./build.sh"],
+                        cwd: "defaultPackage",
+                        group: {
+                            id: "build",
+                            isDefault: true,
+                        },
+                        label: "Default build",
                     },
-                    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);
+                    folderContext.workspaceFolder,
+                    "Default build",
+                    "shell"
+                );
+                nonSwiftTask.group = { id: "build", isDefault: true };
+                swiftTask = new vscode.Task(
+                    {
+                        type: "swift",
+                        args: ["build"],
+                        cwd: "defaultPackage",
+                        label: "swift build",
+                    },
+                    folderContext.workspaceFolder,
+                    "Swift build",
+                    "swift"
+                );
+                swiftTask.group = { id: "build", isDefault: true };
+                return await updateSettings({
+                    "swift.backgroundCompilation": true,
+                    "swift.backgroundCompilationUsesDefaultTask": true,
+                });
+            },
+        });
+
+        setup(() => {
             tasksMock.fetchTasks.resolves([nonSwiftTask, swiftTask, buildAllTask]);
-            tasksMock.fetchTasks.withArgs(match.object).resolves([swiftTask, buildAllTask]);
-            useDefaultTaskConfig.setValue(true);
+            tasksMock.fetchTasks.withArgs(match.object).resolves([swiftTask, buildAllTask]); // Call for fetchTasks({ type: "swift" })
+            backgroundConfiguration = new BackgroundCompilation(folderContext);
         });
 
         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 };
+            await vscode.workspace
+                .getConfiguration("swift")
+                .update("backgroundCompilationUsesDefaultTask", false);
+            expect(await backgroundConfiguration.getTask()).to.equal(buildAllTask);
+        });
+
+        test("non-swift default task", async () => {
+            swiftTask.group = { id: "build", isDefault: false };
             expect(await backgroundConfiguration.getTask()).to.equal(buildAllTask);
         });
     });