Add projectDiscoveryExclude setting and files.watcherExclude support

src/LanguageServer.spec.ts

@@ -544,13 +544,57 @@ describe('LanguageServer', () => {
                     languageServer: {
                         enableThreading: false,
                         enableProjectDiscovery: true,
+                        projectDiscoveryExclude: undefined,
                         logLevel: 'info'
                     }
                 }
             ]);
         });
     });
 
+    describe('projectDiscoveryExclude and files.watcherExclude', () => {
+        it('includes projectDiscoveryExclude in workspace configuration', async () => {
+            const projectDiscoveryExclude = ['**/test/**', 'node_modules/**'];
+
+            sinon.stub(server as any, 'getClientConfiguration').callsFake((workspaceFolder, section) => {
+                if (section === 'brightscript') {
+                    return Promise.resolve({
+                        languageServer: {
+                            projectDiscoveryExclude: projectDiscoveryExclude
+                        }
+                    });
+                }
+                return Promise.resolve({});
+            });
+
+            server.run();
+            const configs = await server['getWorkspaceConfigs']();
+            expect(configs[0].languageServer.projectDiscoveryExclude).to.deep.equal(projectDiscoveryExclude);
+        });
+
+        it('includes files.watcherExclude in workspace exclude patterns', async () => {
+            const watcherExclude = {
+                '**/tmp/**': true,
+                '**/cache/**': true
+            };
+
+            sinon.stub(server as any, 'getClientConfiguration').callsFake((workspaceFolder, section) => {
+                if (section === 'files') {
+                    return Promise.resolve({
+                        exclude: { 'node_modules': true },
+                        watcherExclude: watcherExclude
+                    });
+                }
+                return Promise.resolve({});
+            });
+
+            server.run();
+            const excludeGlobs = await server['getWorkspaceExcludeGlobs'](workspaceFolders[0]);
+            expect(excludeGlobs).to.include('**/tmp/**');
+            expect(excludeGlobs).to.include('**/cache/**');
+        });
+    });
+
     describe('onInitialize', () => {
         it('sets capabilities', async () => {
             server['hasConfigurationCapability'] = false;

src/LanguageServer.ts

@@ -434,6 +434,7 @@ export class LanguageServer {
                     languageServer: {
                         enableThreading: brightscriptConfig.languageServer?.enableThreading ?? LanguageServer.enableThreadingDefault,
                         enableProjectDiscovery: brightscriptConfig.languageServer?.enableProjectDiscovery ?? LanguageServer.enableProjectDiscoveryDefault,
+                        projectDiscoveryExclude: brightscriptConfig.languageServer?.projectDiscoveryExclude,
                         logLevel: brightscriptConfig?.languageServer?.logLevel
                     }
                 };
@@ -647,6 +648,13 @@ export class LanguageServer {
                 this.pathFilterer.registerExcludeList(rootDir, workspaceConfig.excludePatterns)
             );
 
+            //get any `projectDiscoveryExclude` patterns from the client from this workspace
+            if (workspaceConfig.languageServer?.projectDiscoveryExclude) {
+                this.pathFiltererDisposables.push(
+                    this.pathFilterer.registerExcludeList(rootDir, workspaceConfig.languageServer.projectDiscoveryExclude)
+                );
+            }
+
             //get any .gitignore patterns from the client from this workspace
             const gitignorePath = path.resolve(rootDir, '.gitignore');
             if (await fsExtra.pathExists(gitignorePath)) {
@@ -672,16 +680,17 @@ export class LanguageServer {
     }
 
     /**
-     * Ask the client for the list of `files.exclude` patterns. Useful when determining if we should process a file
+     * Ask the client for the list of `files.exclude` and `files.watcherExclude` patterns. Useful when determining if we should process a file
      */
     private async getWorkspaceExcludeGlobs(workspaceFolder: string): Promise<string[]> {
-        const filesConfig = await this.getClientConfiguration<{ exclude: string[] }>(workspaceFolder, 'files');
+        const filesConfig = await this.getClientConfiguration<{ exclude: string[]; watcherExclude: string[] }>(workspaceFolder, 'files');
         const fileExcludes = this.extractExcludes(filesConfig);
+        const watcherExcludes = this.extractExcludes({ exclude: filesConfig?.watcherExclude });
 
         const searchConfig = await this.getClientConfiguration<{ exclude: string[] }>(workspaceFolder, 'search');
         const searchExcludes = this.extractExcludes(searchConfig);
 
-        return [...fileExcludes, ...searchExcludes];
+        return [...fileExcludes, ...watcherExcludes, ...searchExcludes];
     }
 
     private extractExcludes(config: { exclude: string[] }): string[] {
@@ -824,6 +833,7 @@ export interface BrightScriptClientConfiguration {
     languageServer: {
         enableThreading: boolean;
         enableProjectDiscovery: boolean;
+        projectDiscoveryExclude?: string[];
         logLevel: LogLevel | string;
     };
 }

src/lsp/ProjectManager.ts

@@ -945,6 +945,10 @@ export interface WorkspaceConfig {
          * Should the language server automatically discover projects in this workspace?
          */
         enableProjectDiscovery: boolean;
+        /**
+         * A list of glob patterns used to _exclude_ files from project discovery
+         */
+        projectDiscoveryExclude?: string[];
         /**
          * The log level to use for this workspace
          */