Add ignoreSearchingForPackagesInSubfolders setting

Author: plemarquand

package.json

@@ -545,6 +545,22 @@
             "markdownDescription": "Search sub-folders of workspace folder for Swift Packages at start up.",
             "scope": "machine-overridable"
           },
+          "swift.ignoreSearchingForPackagesInSubfolders": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "default": [
+              ".",
+              ".build",
+              "Packages",
+              "out",
+              "bazel-out",
+              "bazel-bin"
+            ],
+            "markdownDescription": "A list of glob patterns to ignore when searching sub-folders for Swift Packages. The `swift.searchSubfoldersForPackages` must be `true` for this setting to have an effect. Always use forward-slashes in glob expressions regardless of platform. This is combined with VS Code's default `files.exclude` setting.",
+            "scope": "machine-overridable"
+          },
           "swift.autoGenerateLaunchConfigurations": {
             "type": "boolean",
             "default": true,

src/WorkspaceContext.ts

@@ -444,6 +444,7 @@ export class WorkspaceContext implements vscode.Disposable {
             workspaceFolder.uri,
             configuration.disableSwiftPMIntegration,
             configuration.folder(workspaceFolder).searchSubfoldersForPackages,
+            configuration.folder(workspaceFolder).ignoreSearchingForPackagesInSubfolders,
             this.globalToolchainSwiftVersion
         );
 

src/configuration.ts

@@ -78,6 +78,8 @@ export interface FolderConfiguration {
     readonly additionalTestArguments: string[];
     /** search sub-folder of workspace folder for Swift Packages */
     readonly searchSubfoldersForPackages: boolean;
+    /** Folders to ignore when searching for Swift Packages */
+    readonly ignoreSearchingForPackagesInSubfolders: string[];
     /** auto-generate launch.json configurations */
     readonly autoGenerateLaunchConfigurations: boolean;
     /** disable automatic running of swift package resolve */
@@ -223,6 +225,15 @@ const configuration = {
                     .getConfiguration("swift", workspaceFolder)
                     .get<boolean>("searchSubfoldersForPackages", false);
             },
+            /** Folders to ignore when searching for Swift Packages */
+            get ignoreSearchingForPackagesInSubfolders(): string[] {
+                return vscode.workspace
+                    .getConfiguration("swift", workspaceFolder)
+                    .get<
+                        string[]
+                    >("ignoreSearchingForPackagesInSubfolders", [".", ".build", "Packages", "out", "bazel-out", "bazel-bin"])
+                    .map(substituteVariablesInString);
+            },
             get attachmentsPath(): string {
                 return substituteVariablesInString(
                     vscode.workspace

src/utilities/workspace.ts

@@ -23,34 +23,28 @@ export async function searchForPackages(
     folder: vscode.Uri,
     disableSwiftPMIntegration: boolean,
     searchSubfoldersForPackages: boolean,
+    skipFolders: Array<string>,
     swiftVersion: Version
 ): Promise<Array<vscode.Uri>> {
     const folders: Array<vscode.Uri> = [];
 
-    async function search(folder: vscode.Uri) {
+    async function search(folder: vscode.Uri, isRoot: boolean = false) {
         // add folder if Package.swift/compile_commands.json/compile_flags.txt/buildServer.json/.bsp exists
         if (await isValidWorkspaceFolder(folder.fsPath, disableSwiftPMIntegration, swiftVersion)) {
             folders.push(folder);
         }
-        // should I search sub-folders for more Swift Packages
+
+        // If sub-folder searches are disabled, don't search subdirectories
         if (!searchSubfoldersForPackages) {
             return;
         }
 
         await globDirectory(folder, { onlyDirectories: true }).then(async entries => {
-            const skipFolders = new Set<string>([
-                ".",
-                ".build",
-                "Packages",
-                "out",
-                "bazel-out",
-                "bazel-bin",
-            ]);
-
+            const skip = new Set<string>(skipFolders);
             for (const entry of entries) {
                 const base = basename(entry);
-                if (!skipFolders.has(base)) {
-                    await search(vscode.Uri.file(entry));
+                if (!skip.has(base)) {
+                    await search(vscode.Uri.file(entry), false);
                 }
             }
         });

test/integration-tests/utilities/workspace.test.ts

@@ -26,6 +26,7 @@ suite("Workspace Utilities Test Suite", () => {
                 (vscode.workspace.workspaceFolders ?? [])[0]!.uri,
                 false,
                 true,
+                [],
                 testSwiftVersion
             );
 

test/unit-tests/utilities/workspace.test.ts

@@ -27,13 +27,95 @@ suite("Workspace Utilities Unit Test Suite", () => {
         const testSwiftVersion = new Version(5, 9, 0);
 
         test("returns only root package when search for subpackages disabled", async () => {
-            const folders = await searchForPackages(packageFolder, false, false, testSwiftVersion);
+            const folders = await searchForPackages(
+                packageFolder,
+                false,
+                false,
+                [],
+                testSwiftVersion
+            );
 
-            expect(folders.map(folder => folder.fsPath)).eql([packageFolder.fsPath]);
+            expect(folders.map(folder => folder.fsPath)).equals([packageFolder.fsPath]);
         });
 
         test("returns subpackages when search for subpackages enabled", async () => {
-            const folders = await searchForPackages(packageFolder, false, true, testSwiftVersion);
+            const folders = await searchForPackages(
+                packageFolder,
+                false,
+                true,
+                [],
+                testSwiftVersion
+            );
+
+            expect(folders.map(folder => folder.fsPath).sort()).deep.equal([
+                packageFolder.fsPath,
+                firstModuleFolder.fsPath,
+                secondModuleFolder.fsPath,
+            ]);
+        });
+
+        test("skips specified folders when skipFolders contains Module1", async () => {
+            const folders = await searchForPackages(
+                packageFolder,
+                false,
+                true,
+                ["Module1"],
+                testSwiftVersion
+            );
+
+            expect(folders.map(folder => folder.fsPath).sort()).deep.equal([
+                packageFolder.fsPath,
+                secondModuleFolder.fsPath,
+            ]);
+        });
+
+        test("skips specified folders when skipFolders contains Module2", async () => {
+            const folders = await searchForPackages(
+                packageFolder,
+                false,
+                true,
+                ["Module2"],
+                testSwiftVersion
+            );
+
+            expect(folders.map(folder => folder.fsPath).sort()).deep.equal([
+                packageFolder.fsPath,
+                firstModuleFolder.fsPath,
+            ]);
+        });
+
+        test("skips multiple folders when skipFolders contains both modules", async () => {
+            const folders = await searchForPackages(
+                packageFolder,
+                false,
+                true,
+                ["Module1", "Module2"],
+                testSwiftVersion
+            );
+
+            expect(folders.map(folder => folder.fsPath)).equals([packageFolder.fsPath]);
+        });
+
+        test("skipFolders has no effect when search for subpackages is disabled", async () => {
+            const folders = await searchForPackages(
+                packageFolder,
+                false,
+                false,
+                ["Module1", "Module2"],
+                testSwiftVersion
+            );
+
+            expect(folders.map(folder => folder.fsPath)).equals([packageFolder.fsPath]);
+        });
+
+        test("skipFolders with non-existent folder names does not affect results", async () => {
+            const folders = await searchForPackages(
+                packageFolder,
+                false,
+                true,
+                ["NonExistentModule", "AnotherFakeModule"],
+                testSwiftVersion
+            );
 
             expect(folders.map(folder => folder.fsPath).sort()).deep.equal([
                 packageFolder.fsPath,