Deeper integration of swift.disableSwiftPMIntegration setting

The `disableSwiftPMIntegration` setting prevented `Package.swift` files
from activating the extension, but if the extension is activated via
compile_commands or bsp integration we still attempt package operations
like `swift package describe` when setting up a `FolderContext`.

If SwiftPM integration has been disabled, return an empty package
representation with no targets or dependencies so that the extension
still activates quickly and provides language features from
sourcekit-lsp without attempting to use SwiftPM.

Issue: #1925

Author: plemarquand

src/FolderContext.ts

@@ -22,6 +22,7 @@ import { TestExplorer } from "./TestExplorer/TestExplorer";
 import { TestRunManager } from "./TestExplorer/TestRunManager";
 import { TestRunProxy } from "./TestExplorer/TestRunner";
 import { FolderOperation, WorkspaceContext } from "./WorkspaceContext";
+import configuration from "./configuration";
 import { SwiftLogger } from "./logging/SwiftLogger";
 import { TaskQueue } from "./tasks/TaskQueue";
 import { SwiftToolchain } from "./toolchain/toolchain";
@@ -135,7 +136,11 @@ export class FolderContext implements vscode.Disposable {
         const { linuxMain, swiftPackage } =
             await workspaceContext.statusItem.showStatusWhileRunning(statusItemText, async () => {
                 const linuxMain = await LinuxMain.create(folder);
-                const swiftPackage = await SwiftPackage.create(folder, toolchain);
+                const swiftPackage = await SwiftPackage.create(
+                    folder,
+                    toolchain,
+                    configuration.disableSwiftPMIntegration
+                );
                 return { linuxMain, swiftPackage };
             });
         workspaceContext.statusItem.end(statusItemText);
@@ -193,7 +198,7 @@ export class FolderContext implements vscode.Disposable {
 
     /** reload swift package for this folder */
     async reload() {
-        await this.swiftPackage.reload(this.toolchain);
+        await this.swiftPackage.reload(this.toolchain, configuration.disableSwiftPMIntegration);
     }
 
     /** reload Package.resolved for this folder */
@@ -208,7 +213,11 @@ export class FolderContext implements vscode.Disposable {
 
     /** Load Swift Plugins and store in Package */
     async loadSwiftPlugins(logger: SwiftLogger) {
-        await this.swiftPackage.loadSwiftPlugins(this.toolchain, logger);
+        await this.swiftPackage.loadSwiftPlugins(
+            this.toolchain,
+            logger,
+            configuration.disableSwiftPMIntegration
+        );
     }
 
     /**

src/SwiftPackage.ts

@@ -211,19 +211,22 @@ export class SwiftPackage {
     /**
      * Create a SwiftPackage from a folder
      * @param folder folder package is in
+     * @param toolchain Swift toolchain to use
+     * @param disableSwiftPMIntegration Whether to disable SwiftPM integration
      * @returns new SwiftPackage
      */
     public static async create(
         folder: vscode.Uri,
-        toolchain: SwiftToolchain
+        toolchain: SwiftToolchain,
+        disableSwiftPMIntegration: boolean = false
     ): Promise<SwiftPackage> {
         const [resolved, workspaceState] = await Promise.all([
             SwiftPackage.loadPackageResolved(folder),
             SwiftPackage.loadWorkspaceState(folder),
         ]);
         return new SwiftPackage(
             folder,
-            SwiftPackage.loadPackage(folder, toolchain),
+            SwiftPackage.loadPackage(folder, toolchain, disableSwiftPMIntegration),
             resolved,
             workspaceState
         );
@@ -250,12 +253,25 @@ export class SwiftPackage {
     /**
      * Run `swift package describe` and return results
      * @param folder folder package is in
+     * @param toolchain Swift toolchain to use
+     * @param disableSwiftPMIntegration Whether to disable SwiftPM integration
      * @returns results of `swift package describe`
      */
     static async loadPackage(
         folder: vscode.Uri,
-        toolchain: SwiftToolchain
+        toolchain: SwiftToolchain,
+        disableSwiftPMIntegration: boolean = false
     ): Promise<SwiftPackageState> {
+        // When SwiftPM integration is disabled, return empty package structure
+        if (disableSwiftPMIntegration) {
+            return {
+                name: path.basename(folder.fsPath),
+                products: [],
+                dependencies: [],
+                targets: [],
+            };
+        }
+
         try {
             // Use swift package describe to describe the package targets, products, and platforms
             // Use swift package show-dependencies to get the dependencies in a tree format
@@ -307,8 +323,14 @@ export class SwiftPackage {
     private static async loadPlugins(
         folder: vscode.Uri,
         toolchain: SwiftToolchain,
-        logger: SwiftLogger
+        logger: SwiftLogger,
+        disableSwiftPMIntegration: boolean = false
     ): Promise<PackagePlugin[]> {
+        // When SwiftPM integration is disabled, return empty plugin list
+        if (disableSwiftPMIntegration) {
+            return [];
+        }
+
         try {
             const { stdout } = await execSwift(["package", "plugin", "--list"], toolchain, {
                 cwd: folder.fsPath,
@@ -355,8 +377,12 @@ export class SwiftPackage {
     }
 
     /** Reload swift package */
-    public async reload(toolchain: SwiftToolchain) {
-        const loadedContents = await SwiftPackage.loadPackage(this.folder, toolchain);
+    public async reload(toolchain: SwiftToolchain, disableSwiftPMIntegration: boolean = false) {
+        const loadedContents = await SwiftPackage.loadPackage(
+            this.folder,
+            toolchain,
+            disableSwiftPMIntegration
+        );
         this._contents = loadedContents;
         this.contentsPromise = Promise.resolve(loadedContents);
     }
@@ -370,8 +396,17 @@ export class SwiftPackage {
         this.workspaceState = await SwiftPackage.loadWorkspaceState(this.folder);
     }
 
-    public async loadSwiftPlugins(toolchain: SwiftToolchain, logger: SwiftLogger) {
-        this.plugins = await SwiftPackage.loadPlugins(this.folder, toolchain, logger);
+    public async loadSwiftPlugins(
+        toolchain: SwiftToolchain,
+        logger: SwiftLogger,
+        disableSwiftPMIntegration: boolean = false
+    ) {
+        this.plugins = await SwiftPackage.loadPlugins(
+            this.folder,
+            toolchain,
+            logger,
+            disableSwiftPMIntegration
+        );
     }
 
     /** Return if has valid contents */

src/ui/ProjectPanelProvider.ts

@@ -672,6 +672,8 @@ export class ProjectPanelProvider implements vscode.TreeDataProvider<TreeNode> {
         const dependencies = await this.dependencies();
         const snippets = await this.snippets();
         const commands = await this.commands();
+        const targets = await this.targets();
+        const tasks = await this.tasks(folderContext);
 
         // TODO: Control ordering
         return [
@@ -685,13 +687,16 @@ export class ProjectPanelProvider implements vscode.TreeDataProvider<TreeNode> {
                       ),
                   ]
                 : []),
-            new HeaderNode("targets", "Targets", "book", this.targets.bind(this)),
-            new HeaderNode(
-                "tasks",
-                "Tasks",
-                "debug-continue-small",
-                this.tasks.bind(this, folderContext)
-            ),
+            ...(targets.length > 0
+                ? [new HeaderNode("targets", "Targets", "book", () => Promise.resolve(targets))]
+                : []),
+            ...(tasks.length > 0
+                ? [
+                      new HeaderNode("tasks", "Tasks", "debug-continue-small", () =>
+                          Promise.resolve(tasks)
+                      ),
+                  ]
+                : []),
             ...(snippets.length > 0
                 ? [
                       new HeaderNode("snippets", "Snippets", "notebook", () =>

test/integration-tests/SwiftPackage.test.ts

@@ -80,4 +80,32 @@ tag("medium").suite("SwiftPackage Test Suite", function () {
         assert.strictEqual(spmPackage.resolved.pins.length, 1);
         assert.strictEqual(spmPackage.resolved.pins[0].identity, "swift-log");
     });
+
+    test("Disabled SwiftPM integration returns empty package", async () => {
+        const spmPackage = await SwiftPackage.create(
+            testAssetUri("package2"),
+            toolchain,
+            true // disableSwiftPMIntegration
+        );
+        assert.strictEqual(await spmPackage.isValid, true);
+        assert.strictEqual(await spmPackage.name, "package2"); // derived from folder name
+        assert.strictEqual((await spmPackage.executableProducts).length, 0);
+        assert.strictEqual((await spmPackage.libraryProducts).length, 0);
+        assert.strictEqual((await spmPackage.dependencies).length, 0);
+        assert.strictEqual((await spmPackage.targets).length, 0);
+    });
+
+    test("Reload with disabled SwiftPM integration returns empty package", async () => {
+        const spmPackage = await SwiftPackage.create(testAssetUri("package2"), toolchain, false);
+        // First verify it loaded normally
+        assert.strictEqual(await spmPackage.isValid, true);
+        assert.strictEqual((await spmPackage.libraryProducts).length, 1);
+
+        // Now reload with disabled integration
+        await spmPackage.reload(toolchain, true);
+        assert.strictEqual(await spmPackage.isValid, true);
+        assert.strictEqual((await spmPackage.libraryProducts).length, 0);
+        assert.strictEqual((await spmPackage.dependencies).length, 0);
+        assert.strictEqual((await spmPackage.targets).length, 0);
+    });
 });