Introduce new swift.excludePathsFromActivation setting (#1693)

* Introduce new `swift.exclude` setting

This will make sure the specified folders are not initialized and
added to the `WorkspaceContext`. SourceKit-LSP will still initialize
if the an excluded file is open in the editor

Issue: #636

* Fix pattern matching when overriding exclusion/inclusion

* Unit tests for pattern matching

* Add user documentation

Include multi-project setup notes as excluding only makes sense in
that context

* Integration test to make sure search exclusion works

* Fix failing unit tests

* Rename setting to `excludePathsFromActivation`

* CHANGELOG entry

Author: award999

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Added
 
 - Added code lenses to run suites/tests, configurable with the `swift.showTestCodeLenses` setting ([#1698](https://github.com/swiftlang/vscode-swift/pull/1698))
+- New `swift.excludePathsFromActivation` setting to ignore specified sub-folders from being activated as projects ([#1693](https://github.com/swiftlang/vscode-swift/pull/1693))
 
 ## 2.8.0 - 2025-07-14
 

assets/test/.vscode/settings.json

@@ -10,5 +10,8 @@
     "lldb.verboseLogging": true,
     "lldb.launch.terminal": "external",
     "lldb-dap.detachOnError": true,
-    "swift.sourcekit-lsp.backgroundIndexing": "off"
+    "swift.sourcekit-lsp.backgroundIndexing": "off",
+    "swift.excludePathsFromActivation": {
+        "**/excluded": true
+    }
 }

assets/test/excluded/Package.swift

@@ -0,0 +1,15 @@
+// swift-tools-version: 5.6
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "excluded",
+    products: [
+        .library(name: "excluded", targets: ["excluded"]),
+    ],
+    dependencies: [],
+    targets: [
+        .target(name: "excluded"),
+    ]
+)

assets/test/excluded/Sources/excluded/excluded.swift

@@ -0,0 +1,6 @@
+public struct excluded {
+    public private(set) var text = "Hello, World!"
+
+    public init() {
+    }
+}

package-lock.json

@@ -796,6 +796,13 @@
             "default": false,
             "markdownDescription": "Disable the running of SourceKit-LSP.",
             "markdownDeprecationMessage": "**Deprecated**: Please use `#swift.sourcekit-lsp.disable#` instead."
+          },
+          "swift.excludePathsFromActivation": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "boolean"
+            },
+            "markdownDescription": "Configure glob patterns for excluding Swift package folders from getting activated. This will take precedence over the glob patterns provided to `files.exclude`."
           }
         }
       },
@@ -1778,6 +1785,7 @@
     "@types/lcov-parse": "^1.0.2",
     "@types/lodash.debounce": "^4.0.9",
     "@types/lodash.throttle": "^4.1.9",
+    "@types/micromatch": "^4.0.9",
     "@types/mocha": "^10.0.10",
     "@types/mock-fs": "^4.13.4",
     "@types/node": "^20.19.7",
@@ -1806,6 +1814,7 @@
     "lint-staged": "^16.1.2",
     "lodash.debounce": "^4.0.8",
     "lodash.throttle": "^4.1.1",
+    "micromatch": "^4.0.8",
     "mocha": "^11.7.1",
     "mock-fs": "^5.5.0",
     "node-pty": "^1.0.0",

package.json

@@ -18,7 +18,7 @@ import { FolderContext } from "./FolderContext";
 import { StatusItem } from "./ui/StatusItem";
 import { SwiftOutputChannel } from "./ui/SwiftOutputChannel";
 import { swiftLibraryPathKey } from "./utilities/utilities";
-import { isPathInsidePath } from "./utilities/filesystem";
+import { isExcluded, isPathInsidePath } from "./utilities/filesystem";
 import { LanguageClientToolchainCoordinator } from "./sourcekit-lsp/LanguageClientToolchainCoordinator";
 import { TemporaryFolder } from "./utilities/tempFolder";
 import { TaskManager } from "./tasks/TaskManager";
@@ -509,6 +509,9 @@ export class WorkspaceContext implements vscode.Disposable {
 
     /** set focus based on the file */
     async focusPackageUri(uri: vscode.Uri) {
+        if (isExcluded(uri)) {
+            return;
+        }
         const packageFolder = await this.getPackageFolder(uri);
         if (packageFolder instanceof FolderContext) {
             await this.focusFolder(packageFolder);

src/WorkspaceContext.ts

@@ -490,6 +490,12 @@ const configuration = {
     get disableSandbox(): boolean {
         return vscode.workspace.getConfiguration("swift").get<boolean>("disableSandbox", false);
     },
+    /** Workspace folder glob patterns to exclude */
+    get excludePathsFromActivation(): Record<string, boolean> {
+        return vscode.workspace
+            .getConfiguration("swift")
+            .get<Record<string, boolean>>("excludePathsFromActivation", {});
+    },
 };
 
 const vsCodeVariableRegex = new RegExp(/\$\{(.+?)\}/g);

src/configuration.ts

@@ -18,6 +18,7 @@ import { FolderContext } from "../FolderContext";
 import { LanguageClientFactory } from "./LanguageClientFactory";
 import { LanguageClientManager } from "./LanguageClientManager";
 import { FolderOperation, WorkspaceContext } from "../WorkspaceContext";
+import { isExcluded } from "../utilities/filesystem";
 
 /**
  * Manages the creation of LanguageClient instances for workspace folders.
@@ -64,6 +65,9 @@ export class LanguageClientToolchainCoordinator implements vscode.Disposable {
         if (!folder) {
             return;
         }
+        if (isExcluded(folder.workspaceFolder.uri)) {
+            return;
+        }
         const singleServer = folder.swiftVersion.isGreaterThanOrEqual(new Version(5, 7, 0));
         switch (operation) {
             case FolderOperation.add: {

src/sourcekit-lsp/LanguageClientToolchainCoordinator.ts

@@ -12,8 +12,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+import { contains } from "micromatch";
 import * as fs from "fs/promises";
 import * as path from "path";
+import * as vscode from "vscode";
+import { convertPathToPattern, glob as fastGlob, Options } from "fast-glob";
+import configuration from "../configuration";
 
 export const validFileTypes = ["swift", "c", "cpp", "h", "hpp", "m", "mm"];
 
@@ -79,3 +83,76 @@ export function expandFilePathTilde(
     }
     return path.join(directory, filepath.slice(1));
 }
+
+function getDefaultExcludeList(): Record<string, boolean> {
+    const config = vscode.workspace.getConfiguration("files");
+    const vscodeExcludeList = config.get<{ [key: string]: boolean }>("exclude", {});
+    const swiftExcludeList = configuration.excludePathsFromActivation;
+    return { ...vscodeExcludeList, ...swiftExcludeList };
+}
+
+function getGlobPattern(excludeList: Record<string, boolean>): {
+    include: string[];
+    exclude: string[];
+} {
+    const exclude: string[] = [];
+    const include: string[] = [];
+    for (const key of Object.keys(excludeList)) {
+        if (excludeList[key]) {
+            exclude.push(key);
+        } else {
+            include.push(key);
+        }
+    }
+    return { include, exclude };
+}
+
+export function isIncluded(
+    uri: vscode.Uri,
+    excludeList: Record<string, boolean> = getDefaultExcludeList()
+): boolean {
+    let notExcluded = true;
+    let included = true;
+    for (const key of Object.keys(excludeList)) {
+        if (excludeList[key]) {
+            if (contains(uri.fsPath, key, { contains: true })) {
+                notExcluded = false;
+                included = false;
+            }
+        } else {
+            if (contains(uri.fsPath, key, { contains: true })) {
+                included = true;
+            }
+        }
+    }
+    if (notExcluded) {
+        return true;
+    }
+    return included;
+}
+
+export function isExcluded(
+    uri: vscode.Uri,
+    excludeList: Record<string, boolean> = getDefaultExcludeList()
+): boolean {
+    return !isIncluded(uri, excludeList);
+}
+
+export async function globDirectory(uri: vscode.Uri, options?: Options): Promise<string[]> {
+    const { include, exclude } = getGlobPattern(getDefaultExcludeList());
+    const matches: string[] = await fastGlob(`${convertPathToPattern(uri.fsPath)}/*`, {
+        ignore: exclude,
+        absolute: true,
+        ...options,
+    });
+    if (include.length > 0) {
+        matches.push(
+            ...(await fastGlob(include, {
+                absolute: true,
+                cwd: uri.fsPath,
+                ...options,
+            }))
+        );
+    }
+    return matches;
+}