brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/LanguageServer.js

@@ -6,39 +6,31 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomCommands = exports.LanguageServer = void 0;
-require("array-flat-polyfill");
-const glob = require("glob");
+exports.NotificationName = exports.CustomCommands = exports.LanguageServer = void 0;
 const path = require("path");
-const rokuDeploy = require("roku-deploy");
+require("array-flat-polyfill");
 const node_1 = require("vscode-languageserver/node");
 const vscode_uri_1 = require("vscode-uri");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
-const deferred_1 = require("./deferred");
-const DiagnosticMessages_1 = require("./DiagnosticMessages");
-const ProgramBuilder_1 = require("./ProgramBuilder");
 const util_1 = require("./util");
-const Logger_1 = require("./Logger");
-const Throttler_1 = require("./Throttler");
-const KeyedThrottler_1 = require("./KeyedThrottler");
 const DiagnosticCollection_1 = require("./DiagnosticCollection");
-const reflection_1 = require("./astUtils/reflection");
 const SemanticTokenUtils_1 = require("./SemanticTokenUtils");
+const logging_1 = require("./logging");
+const ignore_1 = require("ignore");
+const micromatch = require("micromatch");
+const PathFilterer_1 = require("./lsp/PathFilterer");
+const ProjectManager_1 = require("./lsp/ProjectManager");
+const fsExtra = require("fs-extra");
+const deferred_1 = require("./deferred");
+const WorkerThreadProject_1 = require("./lsp/worker/WorkerThreadProject");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const isEqual = require("lodash.isequal");
 class LanguageServer {
     constructor() {
-        this.connection = undefined;
-        this.workspaces = [];
         /**
-         * The number of milliseconds that should be used for language server typing debouncing
+         * The language server protocol connection, used to send and receive all requests and responses
          */
-        this.debounceTimeout = 150;
-        /**
-         * These workspaces are created on the fly whenever a file is opened that is not included
-         * in any of the workspace projects.
-         * Basically these are single-file workspaces to at least get parsing for standalone files.
-         * Also, they should only be created when the file is opened, and destroyed when the file is closed.
-         */
-        this.standaloneFileWorkspaces = {};
+        this.connection = undefined;
         this.hasConfigurationCapability = false;
         /**
          * Indicates whether the client supports workspace folders
@@ -49,77 +41,84 @@ class LanguageServer {
          * The text document manager supports full document sync only
          */
         this.documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
-        this.keyedThrottler = new KeyedThrottler_1.KeyedThrottler(this.debounceTimeout);
-        this.validateThrottler = new Throttler_1.Throttler(0);
-        this.boundValidateAll = this.validateAll.bind(this);
+        this.logger = (0, logging_1.createLogger)({
+            logLevel: logging_1.LogLevel.log
+        });
+        /**
+         * Pending file changes waiting to be flushed after the debounce period
+         */
+        this.pendingFileChanges = [];
+        /**
+         * How long to wait (in ms) after the last file change event before processing the batch.
+         * This prevents excessive revalidation during bulk operations like `git checkout` or package installs.
+         */
+        this.fileChangeDebounceDelay = 300;
+        this.workspaceConfigsCache = new Map();
+        this.busyStatusIndex = -1;
+        this.pathFiltererDisposables = [];
         this.diagnosticCollection = new DiagnosticCollection_1.DiagnosticCollection();
-    }
-    createConnection() {
-        return node_1.createConnection(node_1.ProposedFeatures.all);
-    }
-    validateAllThrottled() {
-        return this.validateThrottler.run(this.boundValidateAll);
+        (0, logging_1.setLspLoggerProps)();
+        //replace the workerPool logger with our own so logging info can be synced
+        WorkerThreadProject_1.workerPool.logger = this.logger.createLogger();
+        this.pathFilterer = new PathFilterer_1.PathFilterer({ logger: this.logger });
+        this.projectManager = new ProjectManager_1.ProjectManager({
+            pathFilterer: this.pathFilterer,
+            logger: this.logger.createLogger()
+        });
+        //anytime a project emits a collection of diagnostics, send them to the client
+        this.projectManager.on('diagnostics', (event) => {
+            this.logger.debug(`Received ${event.diagnostics.length} diagnostics from project ${event.project.projectNumber}`);
+            this.sendDiagnostics(event).catch(logAndIgnoreError);
+        });
+        // Send all open document changes whenever a project is activated. This is necessary because at project startup, the project loads files from disk
+        // and may not have the latest unsaved file changes. Any existing projects that already use these files will just ignore the changes
+        // because the file contents haven't changed.
+        this.projectManager.on('project-activate', (event) => {
+            //keep logLevel in sync with the most verbose log level found across all projects
+            this.syncLogLevel().catch(logAndIgnoreError);
+            //resend all open document changes
+            const documents = [...this.documents.all()];
+            if (documents.length > 0) {
+                this.logger.log(`[${util_1.util.getProjectLogName(event.project)}] loaded or changed. Resending all open document changes.`, documents.map(x => x.uri));
+                for (const document of this.documents.all()) {
+                    this.onTextDocumentDidChangeContent({
+                        document: document
+                    }).catch(logAndIgnoreError);
+                }
+            }
+        });
+        this.projectManager.busyStatusTracker.on('active-runs-change', (event) => {
+            this.sendBusyStatus();
+        });
     }
     //run the server
     run() {
+        var _a;
         // Create a connection for the server. The connection uses Node's IPC as a transport.
-        // Also include all preview / proposed LSP features.
-        this.connection = this.createConnection();
+        this.connection = this.establishConnection();
+        //disable logger colors when running in LSP mode
+        logging_1.logger.enableColor = false;
         //listen to all of the output log events and pipe them into the debug channel in the extension
-        this.loggerSubscription = Logger_1.Logger.subscribe((text) => {
-            this.connection.tracer.log(text);
+        this.loggerSubscription = logging_1.logger.subscribe((message) => {
+            this.connection.tracer.log(message.argsText);
         });
-        this.connection.onInitialize(this.onInitialize.bind(this));
-        this.connection.onInitialized(this.onInitialized.bind(this)); //eslint-disable-line
-        this.connection.onDidChangeConfiguration(this.onDidChangeConfiguration.bind(this)); //eslint-disable-line
-        this.connection.onDidChangeWatchedFiles(this.onDidChangeWatchedFiles.bind(this)); //eslint-disable-line
+        //bind all our on* methods that share the same name from connection
+        for (const name of Object.getOwnPropertyNames(LanguageServer.prototype)) {
+            if (/on+/.test(name) && typeof ((_a = this.connection) === null || _a === void 0 ? void 0 : _a[name]) === 'function') {
+                this.connection[name](this[name].bind(this));
+            }
+        }
+        //Register semantic token requests. TODO switch to a more specific connection function call once they actually add it
+        this.connection.onRequest(node_1.SemanticTokensRequest.method, this.onFullSemanticTokens.bind(this));
+        //file-operation requests live under connection.workspace, so they aren't picked up by the on* auto-bind loop above
+        this.connection.workspace.onWillRenameFiles(this.onWillRenameFiles.bind(this));
         // The content of a text document has changed. This event is emitted
         // when the text document is first opened, when its content has changed,
         // or when document is closed without saving (original contents are sent as a change)
         //
-        this.documents.onDidChangeContent(async (change) => {
-            await this.validateTextDocument(change.document);
-        });
+        this.documents.onDidChangeContent(this.onTextDocumentDidChangeContent.bind(this));
         //whenever a document gets closed
-        this.documents.onDidClose(async (change) => {
-            await this.onDocumentClose(change.document);
-        });
-        // This handler provides the initial list of the completion items.
-        this.connection.onCompletion(async (params) => {
-            return this.onCompletion(params.textDocument.uri, params.position);
-        });
-        // This handler resolves additional information for the item selected in
-        // the completion list.
-        this.connection.onCompletionResolve(this.onCompletionResolve.bind(this));
-        this.connection.onHover(this.onHover.bind(this));
-        this.connection.onExecuteCommand(this.onExecuteCommand.bind(this));
-        this.connection.onDefinition(this.onDefinition.bind(this));
-        this.connection.onDocumentSymbol(this.onDocumentSymbol.bind(this));
-        this.connection.onWorkspaceSymbol(this.onWorkspaceSymbol.bind(this));
-        this.connection.onSignatureHelp(this.onSignatureHelp.bind(this));
-        this.connection.onReferences(this.onReferences.bind(this));
-        this.connection.onCodeAction(this.onCodeAction.bind(this));
-        //TODO switch to a more specific connection function call once they actually add it
-        this.connection.onRequest(node_1.SemanticTokensRequest.method, this.onFullSemanticTokens.bind(this));
-        /*
-        this.connection.onDidOpenTextDocument((params) => {
-             // A text document got opened in VSCode.
-             // params.uri uniquely identifies the document. For documents stored on disk this is a file URI.
-             // params.text the initial full content of the document.
-            this.connection.console.log(`${params.textDocument.uri} opened.`);
-        });
-        this.connection.onDidChangeTextDocument((params) => {
-             // The content of a text document did change in VSCode.
-             // params.uri uniquely identifies the document.
-             // params.contentChanges describe the content changes to the document.
-            this.connection.console.log(`${params.textDocument.uri} changed: ${JSON.stringify(params.contentChanges)}`);
-        });
-        this.connection.onDidCloseTextDocument((params) => {
-             // A text document got closed in VSCode.
-             // params.uri uniquely identifies the document.
-            this.connection.console.log(`${params.textDocument.uri} closed.`);
-        });
-        */
+        this.documents.onDidClose(this.onDocumentClose.bind(this));
         // listen for open, change and close text document events
         this.documents.listen(this.connection);
         // Listen on the connection
@@ -127,7 +126,6 @@ class LanguageServer {
     }
     /**
      * Called when the client starts initialization
-     * @param params
      */
     onInitialize(params) {
         let clientCapabilities = params.capabilities;
@@ -141,7 +139,7 @@ class LanguageServer {
                 textDocumentSync: node_1.TextDocumentSyncKind.Full,
                 // Tell the client that the server supports code completion
                 completionProvider: {
-                    resolveProvider: true,
+                    resolveProvider: false,
                     //anytime the user types a period, auto-show the completion results
                     triggerCharacters: ['.'],
                     allCommitCharacters: ['.', '@']
@@ -154,58 +152,68 @@ class LanguageServer {
                 },
                 referencesProvider: true,
                 codeActionProvider: {
-                    codeActionKinds: [node_1.CodeActionKind.Refactor]
+                    codeActionKinds: [
+                        node_1.CodeActionKind.QuickFix,
+                        node_1.CodeActionKind.Refactor,
+                        node_1.CodeActionKind.SourceFixAll
+                    ]
                 },
                 signatureHelpProvider: {
                     triggerCharacters: ['(', ',']
                 },
                 definitionProvider: true,
                 hoverProvider: true,
+                selectionRangeProvider: true,
                 executeCommandProvider: {
                     commands: [
                         CustomCommands.TranspileFile
                     ]
+                },
+                workspace: {
+                    fileOperations: {
+                        willRename: {
+                            filters: [{
+                                    pattern: {
+                                        glob: '**/*.{bs,brs,xml}',
+                                        matches: 'file'
+                                    }
+                                }]
+                        }
+                    }
                 }
             }
         };
     }
     /**
      * Called when the client has finished initializing
-     * @param params
      */
     async onInitialized() {
-        var _a;
-        let workspaceCreatedDeferred = new deferred_1.Deferred();
-        this.initialWorkspacesCreated = workspaceCreatedDeferred.promise;
+        this.logger.log('onInitialized');
+        //cache a copy of all workspace configurations to use for comparison later
+        this.workspaceConfigsCache = new Map((await this.getWorkspaceConfigs()).map(x => [x.workspaceFolder, x]));
+        //set our logger to the most verbose logLevel found across any project
+        await this.syncLogLevel();
+        this.syncProjectActivationConcurrencyLimit();
         try {
             if (this.hasConfigurationCapability) {
-                // Register for all configuration changes.
-                await this.connection.client.register(node_1.DidChangeConfigurationNotification.type, undefined);
+                // register for when the user changes workspace or user settings
+                await this.connection.client.register(node_1.DidChangeConfigurationNotification.type, {
+                    //we only care about when these settings sections change
+                    section: [
+                        'brightscript',
+                        'files'
+                    ]
+                });
             }
-            //ask the client for all workspace folders
-            let workspaceFolders = (_a = await this.connection.workspace.getWorkspaceFolders()) !== null && _a !== void 0 ? _a : [];
-            let workspacePaths = workspaceFolders.map((x) => {
-                return util_1.util.uriToPath(x.uri);
-            });
-            await this.createWorkspaces(workspacePaths);
+            //populate the path filterer with the client's include/exclude lists
+            await this.rebuildPathFilterer();
+            await this.syncProjects();
             if (this.clientHasWorkspaceFolderCapability) {
+                //if the client changes their workspaces, we need to get our projects in sync
                 this.connection.workspace.onDidChangeWorkspaceFolders(async (evt) => {
-                    //remove programs for removed workspace folders
-                    for (let removed of evt.removed) {
-                        let workspacePath = util_1.util.uriToPath(removed.uri);
-                        let workspace = this.workspaces.find((x) => x.workspacePath === workspacePath);
-                        if (workspace) {
-                            workspace.builder.dispose();
-                            this.workspaces.splice(this.workspaces.indexOf(workspace), 1);
-                        }
-                    }
-                    //create programs for new workspace folders
-                    await this.createWorkspaces(evt.added.map((x) => util_1.util.uriToPath(x.uri)));
+                    await this.syncProjects();
                 });
             }
-            await this.waitAllProgramFirstRuns(false);
-            workspaceCreatedDeferred.resolve();
-            await this.sendDiagnostics();
         }
         catch (e) {
             this.sendCriticalFailure(`Critical failure during BrighterScript language server startup.
@@ -216,695 +224,510 @@ class LanguageServer {
         }
     }
     /**
-     * Send a critical failure notification to the client, which should show a notification of some kind
+     * Set our logLevel to the most verbose log level found across all projects and workspaces
      */
-    sendCriticalFailure(message) {
-        this.connection.sendNotification('critical-failure', message);
-    }
-    /**
-     * Wait for all programs' first run to complete
-     */
-    async waitAllProgramFirstRuns(waitForFirstWorkSpace = true) {
-        if (waitForFirstWorkSpace) {
-            await this.initialWorkspacesCreated;
-        }
-        let status;
-        let workspaces = this.getWorkspaces();
-        for (let workspace of workspaces) {
-            try {
-                await workspace.firstRunPromise;
-            }
-            catch (e) {
-                status = 'critical-error';
-                //the first run failed...that won't change unless we reload the workspace, so replace with resolved promise
-                //so we don't show this error again
-                workspace.firstRunPromise = Promise.resolve();
-                this.sendCriticalFailure(`BrighterScript language server failed to start: \n${e.message}`);
+    async syncLogLevel() {
+        var _a, _b;
+        /**
+         * helper to get the logLevel from a list of items and return the item and level (if found), or undefined if not
+         */
+        const getLogLevel = async (items, fetcher) => {
+            const logLevels = await Promise.all(items.map(async (item) => {
+                let value = await fetcher(item);
+                //force string values to lower case (so we can support things like 'log' or 'Log' or 'LOG')
+                if (typeof value === 'string') {
+                    value = value.toLowerCase();
+                }
+                const logLevelNumeric = this.logger.getLogLevelNumeric(value);
+                if (typeof logLevelNumeric === 'number') {
+                    return logLevelNumeric;
+                }
+                else {
+                    return -1;
+                }
+            }));
+            let idx = logLevels.findIndex(x => x > -1);
+            if (idx > -1) {
+                const mostVerboseLogLevel = Math.max(...logLevels);
+                return {
+                    logLevel: mostVerboseLogLevel,
+                    logLevelText: this.logger.getLogLevelText(mostVerboseLogLevel),
+                    //find the first item having the most verbose logLevel
+                    item: items[logLevels.findIndex(x => x === mostVerboseLogLevel)]
+                };
             }
+        };
+        const workspaces = await this.getWorkspaceConfigs();
+        let workspaceResult = await getLogLevel(workspaces, workspace => { var _a; return (_a = workspace === null || workspace === void 0 ? void 0 : workspace.languageServer) === null || _a === void 0 ? void 0 : _a.logLevel; });
+        if (workspaceResult) {
+            this.logger.info(`Setting global logLevel to '${workspaceResult.logLevelText}' based on configuration from workspace '${(_a = workspaceResult === null || workspaceResult === void 0 ? void 0 : workspaceResult.item) === null || _a === void 0 ? void 0 : _a.workspaceFolder}'`);
+            this.logger.logLevel = workspaceResult.logLevel;
+            return;
+        }
+        let projectResult = await getLogLevel(this.projectManager.projects, (project) => project.logger.logLevel);
+        if (projectResult) {
+            this.logger.info(`Setting global logLevel to '${projectResult.logLevelText}' based on project #${(_b = projectResult === null || projectResult === void 0 ? void 0 : projectResult.item) === null || _b === void 0 ? void 0 : _b.projectNumber}`);
+            this.logger.logLevel = projectResult.logLevel;
+            return;
         }
-        this.connection.sendNotification('build-status', status ? status : 'success');
+        //use a default level if no other level was found
+        this.logger.logLevel = logging_1.LogLevel.log;
     }
     /**
-     * Create project for each new workspace. If the workspace is already known,
-     * it is skipped.
-     * @param workspaceFolders
+     * Get the project activation concurrency limit from all workspaces and set the project manager's concurrency limit to the lowest value found.
+     * This ensures that if the user has multiple workspaces open with different limits,
+     * we respect the most restrictive limit to avoid overwhelming the user's machine.
      */
-    async createWorkspaces(workspacePaths) {
-        return Promise.all(workspacePaths.map(async (workspacePath) => this.createWorkspace(workspacePath)));
+    syncProjectActivationConcurrencyLimit() {
+        const limits = [...this.workspaceConfigsCache]
+            .map(x => { var _a, _b; return (_b = (_a = x === null || x === void 0 ? void 0 : x[1]) === null || _a === void 0 ? void 0 : _a.languageServer) === null || _b === void 0 ? void 0 : _b.projectActivationConcurrencyLimit; })
+            .filter(x => typeof x === 'number');
+        //if we don't have any limits defined, use our default value
+        if (limits.length === 0) {
+            limits.push(LanguageServer.projectActivationConcurrencyLimitDefault);
+        }
+        let concurrencyLimit = Math.min(...limits);
+        //we must always at least support 1 project activating at a time, otherwise no projects would ever activate
+        if (!(concurrencyLimit >= 1)) {
+            this.logger.log(`projectActivationConcurrencyLimit was set to ${concurrencyLimit}, which is not a valid value. Defaulting to 1.`);
+            concurrencyLimit = 1;
+        }
+        this.projectManager.projectActivationConcurrencyLimit = concurrencyLimit;
+    }
+    async onTextDocumentDidChangeContent(event) {
+        this.logger.debug('onTextDocumentDidChangeContent', event.document.uri);
+        await this.projectManager.handleFileChanges([{
+                srcPath: vscode_uri_1.URI.parse(event.document.uri).fsPath,
+                type: node_1.FileChangeType.Changed,
+                fileContents: event.document.getText(),
+                allowStandaloneProject: true
+            }]);
     }
     /**
-     * Event handler for when the program wants to load file contents.
-     * anytime the program wants to load a file, check with our in-memory document cache first
+     * Called when watched files changed (add/change/delete).
+     * The CLIENT is in charge of what files to watch, so all client
+     * implementations should ensure that all valid project
+     * file types are watched (.brs,.bs,.xml,manifest, and any json/text/image files)
+     *
+     * File changes are debounced to batch rapid successive events (e.g. during builds or VCS operations)
+     * into a single processing pass, reducing redundant work across projects.
      */
-    documentFileResolver(srcPath) {
-        let pathUri = vscode_uri_1.URI.file(srcPath).toString();
-        let document = this.documents.get(pathUri);
-        if (document) {
-            return document.getText();
-        }
-    }
-    async getConfigFilePath(workspacePath) {
-        let scopeUri;
-        if (workspacePath.startsWith('file:')) {
-            scopeUri = vscode_uri_1.URI.parse(workspacePath).toString();
-        }
-        else {
-            scopeUri = vscode_uri_1.URI.file(workspacePath).toString();
-        }
-        //look for config group called "brightscript"
-        let config = await this.connection.workspace.getConfiguration({
-            scopeUri: scopeUri,
-            section: 'brightscript'
-        });
-        let configFilePath;
-        //if there's a setting, we need to find the file or show error if it can't be found
-        if (config === null || config === void 0 ? void 0 : config.configFile) {
-            configFilePath = path.resolve(workspacePath, config.configFile);
-            if (await util_1.util.pathExists(configFilePath)) {
-                return configFilePath;
-            }
-            else {
-                this.sendCriticalFailure(`Cannot find config file specified in user/workspace settings at '${configFilePath}'`);
-            }
-        }
-        //default to config file path found in the root of the workspace
-        configFilePath = path.resolve(workspacePath, 'bsconfig.json');
-        if (await util_1.util.pathExists(configFilePath)) {
-            return configFilePath;
-        }
-        //look for the deprecated `brsconfig.json` file
-        configFilePath = path.resolve(workspacePath, 'brsconfig.json');
-        if (await util_1.util.pathExists(configFilePath)) {
-            return configFilePath;
-        }
-        //no config file could be found
-        return undefined;
-    }
-    async createWorkspace(workspacePath) {
-        let workspace = this.workspaces.find((x) => x.workspacePath === workspacePath);
-        //skip this workspace if we already have it
-        if (workspace) {
-            return;
-        }
-        let builder = new ProgramBuilder_1.ProgramBuilder();
-        //prevent clearing the console on run...this isn't the CLI so we want to keep a full log of everything
-        builder.allowConsoleClearing = false;
-        //look for files in our in-memory cache before going to the file system
-        builder.addFileResolver(this.documentFileResolver.bind(this));
-        let configFilePath = await this.getConfigFilePath(workspacePath);
-        let cwd = workspacePath;
-        //if the config file exists, use it and its folder as cwd
-        if (configFilePath && await util_1.util.pathExists(configFilePath)) {
-            cwd = path.dirname(configFilePath);
-        }
-        else {
-            //config file doesn't exist...let `brighterscript` resolve the default way
-            configFilePath = undefined;
-        }
-        let firstRunPromise = builder.run({
-            cwd: cwd,
-            project: configFilePath,
-            watch: false,
-            createPackage: false,
-            deploy: false,
-            copyToStaging: false,
-            showDiagnosticsInConsole: false
-        });
-        firstRunPromise.catch((err) => {
-            console.error(err);
-        });
-        let newWorkspace = {
-            builder: builder,
-            firstRunPromise: firstRunPromise,
-            workspacePath: workspacePath,
-            isFirstRunComplete: false,
-            isFirstRunSuccessful: false,
-            configFilePath: configFilePath,
-            isStandaloneFileWorkspace: false
-        };
-        this.workspaces.push(newWorkspace);
-        await firstRunPromise.then(() => {
-            newWorkspace.isFirstRunComplete = true;
-            newWorkspace.isFirstRunSuccessful = true;
-        }).catch(() => {
-            newWorkspace.isFirstRunComplete = true;
-            newWorkspace.isFirstRunSuccessful = false;
-        }).then(() => {
-            //if we found a deprecated brsconfig.json, add a diagnostic warning the user
-            if (configFilePath && path.basename(configFilePath) === 'brsconfig.json') {
-                builder.addDiagnostic(configFilePath, Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.brsConfigJsonIsDeprecated()), { range: util_1.util.createRange(0, 0, 0, 0) }));
-                return this.sendDiagnostics();
-            }
-        });
+    async onDidChangeWatchedFiles(params) {
+        const workspacePaths = (await this.connection.workspace.getWorkspaceFolders()).map(x => util_1.util.uriToPath(x.uri));
+        const changes = params.changes
+            .map(x => ({
+            srcPath: util_1.util.uriToPath(x.uri),
+            type: x.type,
+            //if this is an open document, allow this file to be loaded in a standalone project (if applicable)
+            allowStandaloneProject: this.documents.get(x.uri) !== undefined
+        }))
+            //exclude all explicit top-level workspace folder paths (to fix a weird macos fs watcher bug that emits events for the workspace folder itself)
+            .filter(x => !workspacePaths.includes(x.srcPath));
+        this.logger.debug('onDidChangeWatchedFiles', changes);
+        //accumulate changes into the pending buffer
+        this.pendingFileChanges.push(...changes);
+        //reset the debounce timer so we batch rapid successive events
+        clearTimeout(this.fileChangeDebounceTimer);
+        //use a deferred so callers can await the completion of the flush
+        if (!this.pendingFileChangesDeferred) {
+            this.pendingFileChangesDeferred = new deferred_1.Deferred();
+        }
+        const deferred = this.pendingFileChangesDeferred;
+        this.fileChangeDebounceTimer = setTimeout(() => {
+            void this.flushFileChanges().then(() => deferred.resolve(), (err) => deferred.reject(err));
+        }, this.fileChangeDebounceDelay);
+        return deferred.promise;
     }
     /**
-     * @param srcPath The absolute path to the source file on disk
+     * Flush all pending file changes accumulated during the debounce window
      */
-    async createStandaloneFileWorkspace(srcPath) {
-        //skip this workspace if we already have it
-        if (this.standaloneFileWorkspaces[srcPath]) {
-            return this.standaloneFileWorkspaces[srcPath];
-        }
-        let builder = new ProgramBuilder_1.ProgramBuilder();
-        //prevent clearing the console on run...this isn't the CLI so we want to keep a full log of everything
-        builder.allowConsoleClearing = false;
-        //look for files in our in-memory cache before going to the file system
-        builder.addFileResolver(this.documentFileResolver.bind(this));
-        //get the path to the directory where this file resides
-        let cwd = path.dirname(srcPath);
-        //get the closest config file and use most of the settings from that
-        let configFilePath = await util_1.util.findClosestConfigFile(srcPath);
-        let project = {};
-        if (configFilePath) {
-            project = util_1.util.normalizeAndResolveConfig({ project: configFilePath });
-        }
-        //override the rootDir and files array
-        project.rootDir = cwd;
-        project.files = [{
-                src: srcPath,
-                dest: path.basename(srcPath)
-            }];
-        let firstRunPromise = builder.run(Object.assign(Object.assign({}, project), { cwd: cwd, project: configFilePath, watch: false, createPackage: false, deploy: false, copyToStaging: false, diagnosticFilters: [
-                //hide the "file not referenced by any other file" error..that's expected in a standalone file.
-                1013
-            ] })).catch((err) => {
-            console.error(err);
+    async flushFileChanges() {
+        //grab all pending changes and clear the buffer, deduping by srcPath (last event wins)
+        const deduped = new Map();
+        for (const change of this.pendingFileChanges.splice(0, this.pendingFileChanges.length)) {
+            deduped.set(change.srcPath, change);
+        }
+        const changes = [...deduped.values()];
+        this.pendingFileChangesDeferred = undefined;
+        //if the client changed any files containing include/exclude patterns, rebuild the path filterer before processing these changes
+        if (micromatch.some(changes.map(x => x.srcPath), [
+            '**/.gitignore',
+            '**/.vscode/settings.json',
+            '**/*bsconfig*.json'
+        ], {
+            dot: true
+        })) {
+            await this.rebuildPathFilterer();
+        }
+        //handle the file changes
+        await this.projectManager.handleFileChanges(changes);
+    }
+    async onDocumentClose(event) {
+        this.logger.debug('onDocumentClose', event.document.uri);
+        await this.projectManager.handleFileClose({
+            srcPath: util_1.util.uriToPath(event.document.uri)
         });
-        let newWorkspace = {
-            builder: builder,
-            firstRunPromise: firstRunPromise,
-            workspacePath: srcPath,
-            isFirstRunComplete: false,
-            isFirstRunSuccessful: false,
-            configFilePath: configFilePath,
-            isStandaloneFileWorkspace: true
-        };
-        this.standaloneFileWorkspaces[srcPath] = newWorkspace;
-        await firstRunPromise.then(() => {
-            newWorkspace.isFirstRunComplete = true;
-            newWorkspace.isFirstRunSuccessful = true;
-        }).catch(() => {
-            newWorkspace.isFirstRunComplete = true;
-            newWorkspace.isFirstRunSuccessful = false;
-        });
-        return newWorkspace;
-    }
-    getWorkspaces() {
-        let workspaces = this.workspaces.slice();
-        for (let key in this.standaloneFileWorkspaces) {
-            workspaces.push(this.standaloneFileWorkspaces[key]);
-        }
-        return workspaces;
     }
     /**
      * Provide a list of completion items based on the current cursor position
-     * @param textDocumentPosition
      */
-    async onCompletion(uri, position) {
-        //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
-        let filePath = util_1.util.uriToPath(uri);
-        //wait until the file has settled
-        await this.keyedThrottler.onIdleOnce(filePath, true);
-        let completions = this
-            .getWorkspaces()
-            .flatMap(workspace => workspace.builder.program.getCompletions(filePath, position));
-        for (let completion of completions) {
-            completion.commitCharacters = ['.'];
-        }
+    async onCompletion(params, cancellationToken, workDoneProgress, resultProgress) {
+        this.logger.debug('onCompletion', params, cancellationToken);
+        const srcPath = util_1.util.uriToPath(params.textDocument.uri);
+        const completions = await this.projectManager.getCompletions({
+            srcPath: srcPath,
+            position: params.position,
+            cancellationToken: cancellationToken
+        });
         return completions;
     }
     /**
-     * Provide a full completion item from the selection
-     * @param item
-     */
-    onCompletionResolve(item) {
-        if (item.data === 1) {
-            item.detail = 'TypeScript details';
-            item.documentation = 'TypeScript documentation';
-        }
-        else if (item.data === 2) {
-            item.detail = 'JavaScript details';
-            item.documentation = 'JavaScript documentation';
-        }
-        return item;
-    }
-    async onCodeAction(params) {
-        //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
-        let srcPath = util_1.util.uriToPath(params.textDocument.uri);
-        //wait until the file has settled
-        await this.keyedThrottler.onIdleOnce(srcPath, true);
-        const codeActions = this
-            .getWorkspaces()
-            //skip programs that don't have this file
-            .filter(x => { var _a, _b; return (_b = (_a = x.builder) === null || _a === void 0 ? void 0 : _a.program) === null || _b === void 0 ? void 0 : _b.hasFile(srcPath); })
-            .flatMap(workspace => workspace.builder.program.getCodeActions(srcPath, params.range));
-        //clone the diagnostics for each code action, since certain diagnostics can have circular reference properties that kill the language server if serialized
-        for (const codeAction of codeActions) {
-            if (codeAction.diagnostics) {
-                codeAction.diagnostics = codeAction.diagnostics.map(x => util_1.util.toDiagnostic(x));
-            }
-        }
-        return codeActions;
-    }
-    /**
-     * Reload all specified workspaces, or all workspaces if no workspaces are specified
-     */
-    async reloadWorkspaces(workspaces) {
-        workspaces = workspaces ? workspaces : this.getWorkspaces();
-        await Promise.all(workspaces.map(async (workspace) => {
-            //ensure the workspace has finished starting up
-            try {
-                await workspace.firstRunPromise;
-            }
-            catch (e) { }
-            //handle standard workspace
-            if (workspace.isStandaloneFileWorkspace === false) {
-                let idx = this.workspaces.indexOf(workspace);
-                if (idx > -1) {
-                    //remove this workspace
-                    this.workspaces.splice(idx, 1);
-                    //dispose this workspace's resources
-                    workspace.builder.dispose();
-                }
-                //create a new workspace/brs program
-                await this.createWorkspace(workspace.workspacePath);
-                //handle temp workspace
-            }
-            else {
-                workspace.builder.dispose();
-                delete this.standaloneFileWorkspaces[workspace.workspacePath];
-                await this.createStandaloneFileWorkspace(workspace.workspacePath);
-            }
-        }));
-        if (workspaces.length > 0) {
-            //wait for all of the programs to finish starting up
-            await this.waitAllProgramFirstRuns();
-            // valdiate all workspaces
-            this.validateAllThrottled(); //eslint-disable-line
-        }
-    }
-    getRootDir(workspace) {
-        var _a, _b, _c;
-        let options = (_b = (_a = workspace === null || workspace === void 0 ? void 0 : workspace.builder) === null || _a === void 0 ? void 0 : _a.program) === null || _b === void 0 ? void 0 : _b.options;
-        return (_c = options === null || options === void 0 ? void 0 : options.rootDir) !== null && _c !== void 0 ? _c : options === null || options === void 0 ? void 0 : options.cwd;
-    }
-    /**
-     * Sometimes users will alter their bsconfig files array, and will include standalone files.
-     * If this is the case, those standalone workspaces should be removed because the file was
-     * included in an actual program now.
-     *
-     * Sometimes files that used to be included are now excluded, so those open files need to be re-processed as standalone
-     */
-    async synchronizeStandaloneWorkspaces() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-        //remove standalone workspaces that are now included in projects
-        for (let standaloneFilePath in this.standaloneFileWorkspaces) {
-            let standaloneWorkspace = this.standaloneFileWorkspaces[standaloneFilePath];
-            for (let workspace of this.workspaces) {
-                await standaloneWorkspace.firstRunPromise;
-                let dest = rokuDeploy.getDestPath(standaloneFilePath, (_d = (_c = (_b = (_a = workspace === null || workspace === void 0 ? void 0 : workspace.builder) === null || _a === void 0 ? void 0 : _a.program) === null || _b === void 0 ? void 0 : _b.options) === null || _c === void 0 ? void 0 : _c.files) !== null && _d !== void 0 ? _d : [], this.getRootDir(workspace));
-                //destroy this standalone workspace because the file has now been included in an actual workspace,
-                //or if the workspace wants the file
-                if (((_f = (_e = workspace === null || workspace === void 0 ? void 0 : workspace.builder) === null || _e === void 0 ? void 0 : _e.program) === null || _f === void 0 ? void 0 : _f.hasFile(standaloneFilePath)) || dest) {
-                    standaloneWorkspace.builder.dispose();
-                    delete this.standaloneFileWorkspaces[standaloneFilePath];
-                }
-            }
-        }
-        //create standalone workspaces for open files that no longer have a project
-        let textDocuments = this.documents.all();
-        outer: for (let textDocument of textDocuments) {
-            let filePath = vscode_uri_1.URI.parse(textDocument.uri).fsPath;
-            let workspaces = this.getWorkspaces();
-            for (let workspace of workspaces) {
-                let dest = rokuDeploy.getDestPath(filePath, (_k = (_j = (_h = (_g = workspace === null || workspace === void 0 ? void 0 : workspace.builder) === null || _g === void 0 ? void 0 : _g.program) === null || _h === void 0 ? void 0 : _h.options) === null || _j === void 0 ? void 0 : _j.files) !== null && _k !== void 0 ? _k : [], this.getRootDir(workspace));
-                //if this workspace has the file, or it wants the file, do NOT make a standalone workspace for this file
-                if (((_m = (_l = workspace === null || workspace === void 0 ? void 0 : workspace.builder) === null || _l === void 0 ? void 0 : _l.program) === null || _m === void 0 ? void 0 : _m.hasFile(filePath)) || dest) {
-                    continue outer;
-                }
-            }
-            //if we got here, no workspace has this file, so make a standalone file workspace
-            let workspace = await this.createStandaloneFileWorkspace(filePath);
-            await workspace.firstRunPromise;
-        }
-    }
-    async onDidChangeConfiguration() {
-        if (this.hasConfigurationCapability) {
-            await this.reloadWorkspaces();
-            // Reset all cached document settings
-        }
-        else {
-            // this.globalSettings = <ExampleSettings>(
-            //     (change.settings.languageServerExample || this.defaultSettings)
-            // );
-        }
-    }
-    /**
-     * Called when watched files changed (add/change/delete).
-     * The CLIENT is in charge of what files to watch, so all client
-     * implementations should ensure that all valid project
-     * file types are watched (.brs,.bs,.xml,manifest, and any json/text/image files)
-     * @param params
+     * Get a list of workspaces, and their configurations.
+     * Get only the settings for the workspace that are relevant to the language server. We do this so we can cache this object for use in change detection in the future.
      */
-    async onDidChangeWatchedFiles(params) {
-        //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
-        this.connection.sendNotification('build-status', 'building');
-        let workspaces = this.getWorkspaces();
-        //convert all file paths to absolute paths
-        let changes = params.changes.map(x => {
+    async getWorkspaceConfigs() {
+        var _a;
+        //get all workspace folders (we'll use these to get settings)
+        let workspaces = await Promise.all(((_a = await this.connection.workspace.getWorkspaceFolders()) !== null && _a !== void 0 ? _a : []).map(async (x) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const workspaceFolder = util_1.util.uriToPath(x.uri);
+            const brightscriptConfig = await this.getClientConfiguration(x.uri, 'brightscript');
             return {
-                type: x.type,
-                srcPath: util_1.standardizePath `${vscode_uri_1.URI.parse(x.uri).fsPath}`
-            };
-        });
-        let keys = changes.map(x => x.srcPath);
-        //filter the list of changes to only the ones that made it through the debounce unscathed
-        changes = changes.filter(x => keys.includes(x.srcPath));
-        //if we have changes to work with
-        if (changes.length > 0) {
-            //reload any workspace whose bsconfig.json file has changed
-            {
-                let workspacesToReload = [];
-                //get the file paths as a string array
-                let filePaths = changes.map((x) => x.srcPath);
-                for (let workspace of workspaces) {
-                    if (workspace.configFilePath && filePaths.includes(workspace.configFilePath)) {
-                        workspacesToReload.push(workspace);
-                    }
+                workspaceFolder: workspaceFolder,
+                excludePatterns: await this.getWorkspaceExcludeGlobs(workspaceFolder),
+                projects: this.normalizeProjectPaths(workspaceFolder, brightscriptConfig === null || brightscriptConfig === void 0 ? void 0 : brightscriptConfig.projects),
+                languageServer: {
+                    enableThreading: (_b = (_a = brightscriptConfig === null || brightscriptConfig === void 0 ? void 0 : brightscriptConfig.languageServer) === null || _a === void 0 ? void 0 : _a.enableThreading) !== null && _b !== void 0 ? _b : LanguageServer.enableThreadingDefault,
+                    enableProjectDiscovery: (_d = (_c = brightscriptConfig === null || brightscriptConfig === void 0 ? void 0 : brightscriptConfig.languageServer) === null || _c === void 0 ? void 0 : _c.enableProjectDiscovery) !== null && _d !== void 0 ? _d : LanguageServer.enableProjectDiscoveryDefault,
+                    projectDiscoveryMaxDepth: (_f = (_e = brightscriptConfig === null || brightscriptConfig === void 0 ? void 0 : brightscriptConfig.languageServer) === null || _e === void 0 ? void 0 : _e.projectDiscoveryMaxDepth) !== null && _f !== void 0 ? _f : 15,
+                    projectDiscoveryExclude: (_g = brightscriptConfig === null || brightscriptConfig === void 0 ? void 0 : brightscriptConfig.languageServer) === null || _g === void 0 ? void 0 : _g.projectDiscoveryExclude,
+                    logLevel: (_h = brightscriptConfig === null || brightscriptConfig === void 0 ? void 0 : brightscriptConfig.languageServer) === null || _h === void 0 ? void 0 : _h.logLevel,
+                    projectActivationConcurrencyLimit: (_j = brightscriptConfig === null || brightscriptConfig === void 0 ? void 0 : brightscriptConfig.languageServer) === null || _j === void 0 ? void 0 : _j.projectActivationConcurrencyLimit
                 }
-                if (workspacesToReload.length > 0) {
-                    //vsc can generate a ton of these changes, for vsc system files, so we need to bail if there's no work to do on any of our actual workspace files
-                    //reload any workspaces that need to be reloaded
-                    await this.reloadWorkspaces(workspacesToReload);
-                }
-                //set the list of workspaces to non-reloaded workspaces
-                workspaces = workspaces.filter(x => !workspacesToReload.includes(x));
-            }
-            //convert created folders into a list of files of their contents
-            const directoryChanges = changes
-                //get only creation items
-                .filter(change => change.type === node_1.FileChangeType.Created)
-                //keep only the directories
-                .filter(change => util_1.util.isDirectorySync(change.srcPath));
-            //remove the created directories from the changes array (we will add back each of their files next)
-            changes = changes.filter(x => !directoryChanges.includes(x));
-            //look up every file in each of the newly added directories
-            const newFileChanges = directoryChanges
-                //take just the path
-                .map(x => x.srcPath)
-                //exclude the roku deploy staging folder
-                .filter(dirPath => !dirPath.includes('.roku-deploy-staging'))
-                //get the files for each folder recursively
-                .flatMap(dirPath => {
-                //create a glob pattern to match all files
-                let pattern = rokuDeploy.util.toForwardSlashes(`${dirPath}/**/*`);
-                let files = glob.sync(pattern, {
-                    absolute: true
-                });
-                return files.map(x => {
-                    return {
-                        type: node_1.FileChangeType.Created,
-                        srcPath: util_1.standardizePath `${x}`
-                    };
-                });
-            });
-            //add the new file changes to the changes array.
-            changes.push(...newFileChanges);
-            //give every workspace the chance to handle file changes
-            await Promise.all(workspaces.map((workspace) => this.handleFileChanges(workspace, changes)));
-        }
-        this.connection.sendNotification('build-status', 'success');
-    }
-    /**
-     * This only operates on files that match the specified files globs, so it is safe to throw
-     * any file changes you receive with no unexpected side-effects
-     * @param changes
-     */
-    async handleFileChanges(workspace, changes) {
-        //this loop assumes paths are both file paths and folder paths, which eliminates the need to detect.
-        //All functions below can handle being given a file path AND a folder path, and will only operate on the one they are looking for
-        let consumeCount = 0;
-        await Promise.all(changes.map(async (change) => {
-            await this.keyedThrottler.run(change.srcPath, async () => {
-                consumeCount += await this.handleFileChange(workspace, change) ? 1 : 0;
-            });
+            };
         }));
-        if (consumeCount > 0) {
-            await this.validateAllThrottled();
-        }
+        return workspaces;
     }
     /**
-     * This only operates on files that match the specified files globs, so it is safe to throw
-     * any file changes you receive with no unexpected side-effects
-     * @param changes
+     * Extract project paths from settings' projects list, expanding the workspaceFolder variable if necessary
      */
-    async handleFileChange(workspace, change) {
-        const program = workspace.builder.program;
-        const options = workspace.builder.options;
-        const rootDir = workspace.builder.rootDir;
-        //deleted
-        if (change.type === node_1.FileChangeType.Deleted) {
-            //try to act on this path as a directory
-            workspace.builder.program.removeFilesInFolder(change.srcPath);
-            //if this is a file loaded in the program, remove it
-            if (program.hasFile(change.srcPath)) {
-                program.removeFile(change.srcPath);
-                return true;
+    normalizeProjectPaths(workspaceFolder, projects) {
+        return projects === null || projects === void 0 ? void 0 : projects.reduce((acc, project) => {
+            if (typeof project === 'string') {
+                acc.push({ path: project });
             }
-            else {
-                return false;
+            else if (typeof project.path === 'string') {
+                acc.push(project);
             }
-            //created
-        }
-        else if (change.type === node_1.FileChangeType.Created) {
-            // thanks to `onDidChangeWatchedFiles`, we can safely assume that all "Created" changes are file paths, (not directories)
-            //get the dest path for this file.
-            let destPath = rokuDeploy.getDestPath(change.srcPath, options.files, rootDir);
-            //if we got a dest path, then the program wants this file
-            if (destPath) {
-                program.setFile({
-                    src: change.srcPath,
-                    dest: rokuDeploy.getDestPath(change.srcPath, options.files, rootDir)
-                }, await workspace.builder.getFileContents(change.srcPath));
-                return true;
-            }
-            else {
-                //no dest path means the program doesn't want this file
-                return false;
-            }
-            //changed
-        }
-        else if (program.hasFile(change.srcPath)) {
-            //sometimes "changed" events are emitted on files that were actually deleted,
-            //so determine file existance and act accordingly
-            if (await util_1.util.pathExists(change.srcPath)) {
-                program.setFile({
-                    src: change.srcPath,
-                    dest: rokuDeploy.getDestPath(change.srcPath, options.files, rootDir)
-                }, await workspace.builder.getFileContents(change.srcPath));
-            }
-            else {
-                program.removeFile(change.srcPath);
-            }
-            return true;
+            return acc;
+        }, []).map(project => (Object.assign(Object.assign({}, project), { 
+            // eslint-disable-next-line no-template-curly-in-string
+            path: util_1.util.standardizePath(project.path.replace('${workspaceFolder}', workspaceFolder)) })));
+    }
+    async onDidChangeConfiguration(args) {
+        this.logger.log('onDidChangeConfiguration', 'Reloading all projects');
+        const configs = new Map((await this.getWorkspaceConfigs()).map(x => [x.workspaceFolder, x]));
+        //find any changed configs. This includes newly created workspaces, deleted workspaces, etc.
+        //TODO: enhance this to only reload specific projects, depending on the change
+        if (!isEqual(configs, this.workspaceConfigsCache)) {
+            //now that we've processed any config diffs, update the cached copy of them
+            this.workspaceConfigsCache = configs;
+            this.syncProjectActivationConcurrencyLimit();
+            //if configuration changed, rebuild the path filterer
+            await this.rebuildPathFilterer();
+            //if the user changes any user/workspace config settings, just mass-reload all projects
+            await this.syncProjects(true);
         }
     }
     async onHover(params) {
-        //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
-        let srcPath = util_1.util.uriToPath(params.textDocument.uri);
-        let workspaces = this.getWorkspaces();
-        let hovers = await Promise.all(Array.prototype.concat.call([], workspaces.map(async (x) => x.builder.program.getHover(srcPath, params.position))));
-        //return the first non-falsey hover. TODO is there a way to handle multiple hover results?
-        let hover = hovers.filter((x) => !!x)[0];
-        //TODO improve this to support more than just .brs files
-        if (hover === null || hover === void 0 ? void 0 : hover.contents) {
-            //create fenced code block to get colorization
-            hover.contents = {
-                //TODO - make the program.getHover call figure out what language this is for
-                language: 'brightscript',
-                value: hover.contents
-            };
-        }
-        return hover;
-    }
-    async onDocumentClose(textDocument) {
-        let filePath = vscode_uri_1.URI.parse(textDocument.uri).fsPath;
-        let standaloneFileWorkspace = this.standaloneFileWorkspaces[filePath];
-        //if this was a temp file, close it
-        if (standaloneFileWorkspace) {
-            await standaloneFileWorkspace.firstRunPromise;
-            standaloneFileWorkspace.builder.dispose();
-            delete this.standaloneFileWorkspaces[filePath];
-            await this.sendDiagnostics();
-        }
-    }
-    async validateTextDocument(textDocument) {
-        //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
-        let filePath = vscode_uri_1.URI.parse(textDocument.uri).fsPath;
-        try {
-            //throttle file processing. first call is run immediately, and then the last call is processed.
-            await this.keyedThrottler.run(filePath, () => {
-                var _a;
-                this.connection.sendNotification('build-status', 'building');
-                let documentText = textDocument.getText();
-                for (const workspace of this.getWorkspaces()) {
-                    //only add or replace existing files. All of the files in the project should
-                    //have already been loaded by other means
-                    if (workspace.builder.program.hasFile(filePath)) {
-                        let rootDir = (_a = workspace.builder.program.options.rootDir) !== null && _a !== void 0 ? _a : workspace.builder.program.options.cwd;
-                        let dest = rokuDeploy.getDestPath(filePath, workspace.builder.program.options.files, rootDir);
-                        workspace.builder.program.setFile({
-                            src: filePath,
-                            dest: dest
-                        }, documentText);
-                    }
-                }
-            });
-            // validate all workspaces
-            await this.validateAllThrottled();
-        }
-        catch (e) {
-            this.sendCriticalFailure(`Critical error parsing/ validating ${filePath}: ${e.message}`);
-        }
-    }
-    async validateAll() {
-        var _a;
-        try {
-            //synchronize parsing for open files that were included/excluded from projects
-            await this.synchronizeStandaloneWorkspaces();
-            let workspaces = this.getWorkspaces();
-            //validate all programs
-            await Promise.all(workspaces.map((x) => x.builder.program.validate()));
-            await this.sendDiagnostics();
-        }
-        catch (e) {
-            this.connection.console.error(e);
-            this.sendCriticalFailure(`Critical error validating workspace: ${e.message}${(_a = e.stack) !== null && _a !== void 0 ? _a : ''}`);
-        }
-        this.connection.sendNotification('build-status', 'success');
+        this.logger.debug('onHover', params);
+        const srcPath = util_1.util.uriToPath(params.textDocument.uri);
+        const result = await this.projectManager.getHover({ srcPath: srcPath, position: params.position });
+        return result;
     }
     async onWorkspaceSymbol(params) {
-        await this.waitAllProgramFirstRuns();
-        const results = util_1.util.flatMap(await Promise.all(this.getWorkspaces().map(workspace => {
-            return workspace.builder.program.getWorkspaceSymbols();
-        })), c => c);
-        // Remove duplicates
-        const allSymbols = Object.values(results.reduce((map, symbol) => {
-            const key = symbol.location.uri + symbol.name;
-            map[key] = symbol;
-            return map;
-        }, {}));
-        return allSymbols;
+        this.logger.debug('onWorkspaceSymbol', params);
+        const result = await this.projectManager.getWorkspaceSymbol();
+        return result;
+    }
+    async onSelectionRanges(params) {
+        this.logger.debug('onSelectionRanges', params);
+        const srcPath = util_1.util.uriToPath(params.textDocument.uri);
+        return this.projectManager.getSelectionRanges({ srcPath: srcPath, positions: params.positions });
     }
     async onDocumentSymbol(params) {
-        await this.waitAllProgramFirstRuns();
-        await this.keyedThrottler.onIdleOnce(util_1.util.uriToPath(params.textDocument.uri), true);
+        this.logger.debug('onDocumentSymbol', params);
         const srcPath = util_1.util.uriToPath(params.textDocument.uri);
-        for (const workspace of this.getWorkspaces()) {
-            const file = workspace.builder.program.getFile(srcPath);
-            if (reflection_1.isBrsFile(file)) {
-                return file.getDocumentSymbols();
-            }
-        }
+        const result = await this.projectManager.getDocumentSymbol({ srcPath: srcPath });
+        return result;
     }
     async onDefinition(params) {
-        await this.waitAllProgramFirstRuns();
+        this.logger.debug('onDefinition', params);
         const srcPath = util_1.util.uriToPath(params.textDocument.uri);
-        const results = util_1.util.flatMap(await Promise.all(this.getWorkspaces().map(workspace => {
-            return workspace.builder.program.getDefinition(srcPath, params.position);
-        })), c => c);
-        return results;
+        const result = this.projectManager.getDefinition({ srcPath: srcPath, position: params.position });
+        return result;
     }
     async onSignatureHelp(params) {
-        var _a, _b, _c;
-        await this.waitAllProgramFirstRuns();
-        const filepath = util_1.util.uriToPath(params.textDocument.uri);
-        await this.keyedThrottler.onIdleOnce(filepath, true);
-        try {
-            const signatures = util_1.util.flatMap(await Promise.all(this.getWorkspaces().map(workspace => workspace.builder.program.getSignatureHelp(filepath, params.position))), c => c);
-            const activeSignature = signatures.length > 0 ? 0 : null;
-            const activeParameter = activeSignature >= 0 ? (_a = signatures[activeSignature]) === null || _a === void 0 ? void 0 : _a.index : null;
-            let results = {
-                signatures: signatures.map((s) => s.signature),
-                activeSignature: activeSignature,
-                activeParameter: activeParameter
-            };
-            return results;
+        this.logger.debug('onSignatureHelp', params);
+        const srcPath = util_1.util.uriToPath(params.textDocument.uri);
+        const result = await this.projectManager.getSignatureHelp({ srcPath: srcPath, position: params.position });
+        if (result) {
+            return result;
         }
-        catch (e) {
-            this.connection.console.error(`error in onSignatureHelp: ${(_c = (_b = e.stack) !== null && _b !== void 0 ? _b : e.message) !== null && _c !== void 0 ? _c : e}`);
+        else {
             return {
                 signatures: [],
-                activeSignature: 0,
-                activeParameter: 0
+                activeSignature: null,
+                activeParameter: null
             };
         }
     }
     async onReferences(params) {
-        await this.waitAllProgramFirstRuns();
-        const position = params.position;
+        this.logger.debug('onReferences', params);
         const srcPath = util_1.util.uriToPath(params.textDocument.uri);
-        const results = util_1.util.flatMap(await Promise.all(this.getWorkspaces().map(workspace => {
-            return workspace.builder.program.getReferences(srcPath, position);
-        })), c => c);
-        return results.filter((r) => r);
+        const result = await this.projectManager.getReferences({ srcPath: srcPath, position: params.position });
+        return result !== null && result !== void 0 ? result : [];
+    }
+    async onWillRenameFiles(params) {
+        var _a, _b;
+        var _c;
+        this.logger.debug('onWillRenameFiles', params);
+        const changes = {};
+        for (const file of (_a = params.files) !== null && _a !== void 0 ? _a : []) {
+            const oldSrcPath = util_1.util.uriToPath(file.oldUri);
+            const newSrcPath = util_1.util.uriToPath(file.newUri);
+            const edits = await this.projectManager.getFileRenameEdits({ oldSrcPath: oldSrcPath, newSrcPath: newSrcPath });
+            for (const edit of edits) {
+                ((_b = changes[_c = edit.uri]) !== null && _b !== void 0 ? _b : (changes[_c] = [])).push({
+                    range: edit.range,
+                    newText: edit.newText
+                });
+            }
+        }
+        if (Object.keys(changes).length === 0) {
+            return null;
+        }
+        return { changes: changes };
     }
     async onFullSemanticTokens(params) {
-        await this.waitAllProgramFirstRuns();
-        await this.keyedThrottler.onIdleOnce(util_1.util.uriToPath(params.textDocument.uri), true);
+        this.logger.debug('onFullSemanticTokens', params);
         const srcPath = util_1.util.uriToPath(params.textDocument.uri);
-        for (const workspace of this.workspaces) {
-            //find the first program that has this file, since it would be incredibly inefficient to generate semantic tokens for the same file multiple times.
-            if (workspace.builder.program.hasFile(srcPath)) {
-                let semanticTokens = workspace.builder.program.getSemanticTokens(srcPath);
-                return {
-                    data: SemanticTokenUtils_1.encodeSemanticTokens(semanticTokens)
-                };
-            }
-        }
+        const result = await this.projectManager.getSemanticTokens({ srcPath: srcPath });
+        return {
+            data: (0, SemanticTokenUtils_1.encodeSemanticTokens)(result)
+        };
     }
-    async sendDiagnostics() {
-        //Get only the changes to diagnostics since the last time we sent them to the client
-        const patch = await this.diagnosticCollection.getPatch(this.workspaces);
-        for (let filePath in patch) {
-            const diagnostics = patch[filePath].map(d => util_1.util.toDiagnostic(d));
-            this.connection.sendDiagnostics({
-                uri: vscode_uri_1.URI.file(filePath).toString(),
-                diagnostics: diagnostics
-            });
-        }
+    async onCodeAction(params) {
+        var _a, _b;
+        this.logger.debug('onCodeAction', params);
+        const srcPath = util_1.util.uriToPath(params.textDocument.uri);
+        const requestedKinds = (_b = (_a = params.context) === null || _a === void 0 ? void 0 : _a.only) !== null && _b !== void 0 ? _b : [];
+        const wantsAnyKind = requestedKinds.length === 0;
+        // Fix-all is opt-in and expensive, so only fetch when the client asks for it.
+        const fixAllKind = node_1.CodeActionKind.SourceFixAll;
+        const wantsFixAll = wantsAnyKind ||
+            requestedKinds.some(kind => kind.startsWith(fixAllKind) || fixAllKind.startsWith(kind));
+        // Standard actions (quickfix, refactor, etc.) all come through getCodeActions,
+        // so only skip that pipeline when the client explicitly asked for fix-all only.
+        const wantsStandardActions = wantsAnyKind ||
+            requestedKinds.some(kind => !kind.startsWith(fixAllKind));
+        const [standardActions, fixAllActions] = await Promise.all([
+            wantsStandardActions ? this.projectManager.getCodeActions({ srcPath: srcPath, range: params.range }) : [],
+            wantsFixAll ? this.projectManager.getFixAllCodeActions({ srcPath: srcPath }) : []
+        ]);
+        const result = [...(standardActions !== null && standardActions !== void 0 ? standardActions : []), ...(fixAllActions !== null && fixAllActions !== void 0 ? fixAllActions : [])];
+        // filter out any code actions with a kind that the client did not ask for (if the client specified any kinds at all)
+        if (!wantsAnyKind) {
+            return result.filter(x => x.kind && requestedKinds.some(only => x.kind === only || x.kind.startsWith(only + '.')));
+        }
+        return result;
     }
     async onExecuteCommand(params) {
-        await this.waitAllProgramFirstRuns();
+        this.logger.debug('onExecuteCommand', params);
         if (params.command === CustomCommands.TranspileFile) {
-            return this.transpileFile(params.arguments[0]);
+            const args = {
+                srcPath: params.arguments[0]
+            };
+            const result = await this.projectManager.transpileFile(args);
+            //back-compat: include `pathAbsolute` property so older vscode versions still work
+            result.pathAbsolute = result.srcPath;
+            return result;
         }
     }
     /**
-     * @param srcPath The absolute path to the source file on disk
+     * Establish a connection to the client if not already connected
+     */
+    establishConnection() {
+        if (!this.connection) {
+            this.connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
+        }
+        return this.connection;
+    }
+    /**
+     * Send a new busy status notification to the client based on the current busy status
+     */
+    sendBusyStatus() {
+        var _a;
+        this.busyStatusIndex = ++this.busyStatusIndex <= 0 ? 0 : this.busyStatusIndex;
+        (_a = this.connection.sendNotification(NotificationName.busyStatus, {
+            status: this.projectManager.busyStatusTracker.status,
+            timestamp: Date.now(),
+            index: this.busyStatusIndex,
+            activeRuns: [
+                //extract only specific information from the active run so we know what's going on
+                ...this.projectManager.busyStatusTracker.activeRuns.map(x => ({
+                    scope: util_1.util.getProjectLogName(x.scope),
+                    label: x.label,
+                    startTime: x.startTime.getTime()
+                }))
+            ]
+        })) === null || _a === void 0 ? void 0 : _a.catch(logAndIgnoreError);
+    }
+    /**
+     * Populate the path filterer with the client's include/exclude lists and the projects include lists
+     * @returns the instance of the path filterer
+     */
+    async rebuildPathFilterer() {
+        var _a;
+        //dispose of any previous pathFilterer disposables
+        (_a = this.pathFiltererDisposables) === null || _a === void 0 ? void 0 : _a.forEach(dispose => dispose());
+        //keep track of all the pathFilterer disposables so we can dispose them later
+        this.pathFiltererDisposables = [];
+        const workspaceConfigs = await this.getWorkspaceConfigs();
+        await Promise.all(workspaceConfigs.map(async (workspaceConfig) => {
+            const rootDir = util_1.util.uriToPath(workspaceConfig.workspaceFolder);
+            //always exclude everything from these common folders
+            this.pathFiltererDisposables.push(this.pathFilterer.registerExcludeList(rootDir, [
+                '**/node_modules/**/*',
+                '**/.git/**/*',
+                'out/**/*',
+                '**/.roku-deploy-staging/**/*'
+            ]));
+            //get any `files.exclude` patterns from the client from this workspace
+            this.pathFiltererDisposables.push(this.pathFilterer.registerExcludeList(rootDir, workspaceConfig.excludePatterns));
+            //get any .gitignore patterns from the client from this workspace
+            const gitignorePath = path.resolve(rootDir, '.gitignore');
+            if (await fsExtra.pathExists(gitignorePath)) {
+                const matcher = (0, ignore_1.default)({ ignoreCase: true }).add(fsExtra.readFileSync(gitignorePath).toString());
+                this.pathFiltererDisposables.push(this.pathFilterer.registerExcludeMatcher((p) => {
+                    const relPath = path.relative(rootDir, p);
+                    if (ignore_1.default.isPathValid(relPath)) {
+                        return matcher.test(relPath).ignored;
+                    }
+                    else {
+                        //we do not have a valid relative path, so we cannot determine if it is ignored...thus it is NOT ignored
+                        return false;
+                    }
+                }));
+            }
+        }));
+        this.logger.log('pathFilterer successfully reconstructed');
+        return this.pathFilterer;
+    }
+    /**
+     * Ask the client for the list of `files.exclude` and `files.watcherExclude` patterns. Useful when determining if we should process a file
      */
-    async transpileFile(srcPath) {
-        //wait all program first runs
-        await this.waitAllProgramFirstRuns();
-        let workspaces = this.getWorkspaces();
-        //find the first workspace that has this file
-        for (let workspace of workspaces) {
-            if (workspace.builder.program.hasFile(srcPath)) {
-                return workspace.builder.program.getTranspiledFileContents(srcPath);
+    async getWorkspaceExcludeGlobs(workspaceFolder) {
+        var _a;
+        const filesConfig = await this.getClientConfiguration(workspaceFolder, 'files');
+        const searchConfig = await this.getClientConfiguration(workspaceFolder, 'search');
+        const languageServerConfig = await this.getClientConfiguration(workspaceFolder, 'brightscript');
+        return [
+            ...this.extractExcludes(filesConfig === null || filesConfig === void 0 ? void 0 : filesConfig.exclude),
+            ...this.extractExcludes(filesConfig === null || filesConfig === void 0 ? void 0 : filesConfig.watcherExclude),
+            ...this.extractExcludes(searchConfig === null || searchConfig === void 0 ? void 0 : searchConfig.exclude),
+            ...this.extractExcludes((_a = languageServerConfig === null || languageServerConfig === void 0 ? void 0 : languageServerConfig.languageServer) === null || _a === void 0 ? void 0 : _a.projectDiscoveryExclude)
+        ];
+    }
+    extractExcludes(exclude) {
+        //if the exclude is not defined, return an empty array
+        if (!exclude) {
+            return [];
+        }
+        return Object
+            .keys(exclude)
+            .filter(x => exclude[x])
+            //vscode files.exclude patterns support ignoring folders without needing to add `**/*`. So for our purposes, we need to
+            //append **/* to everything without a file extension or magic at the end
+            .map(pattern => {
+            const result = [
+                //send the pattern as-is (this handles weird cases and exact file matches)
+                pattern
+            ];
+            //treat the pattern as a directory (no harm in doing this because if it's a file, the pattern will just never match anything)
+            if (!pattern.endsWith('/**/*')) {
+                result.push(`${pattern}/**/*`);
             }
+            return result;
+        })
+            .flat(1);
+    }
+    /**
+     * Ask the project manager to sync all projects found within the list of workspaces
+     * @param forceReload if true, all projects are discarded and recreated from scratch
+     */
+    async syncProjects(forceReload = false) {
+        const workspaces = await this.getWorkspaceConfigs();
+        await this.projectManager.syncProjects(workspaces, forceReload);
+        //set our logLevel to the most verbose log level found across all projects and workspaces
+        await this.syncLogLevel();
+    }
+    /**
+     * Given a workspaceFolder path, get the specified configuration from the client (if applicable).
+     * Be sure to use optional chaining to traverse the result in case that configuration doesn't exist or the client doesn't support `getConfiguration`
+     * @param workspaceFolder the folder for the workspace in the client
+     */
+    async getClientConfiguration(workspaceFolder, section) {
+        const scopeUri = util_1.util.pathToUri(workspaceFolder);
+        let config = {};
+        //if the client supports configuration, look for config group called "brightscript"
+        if (this.hasConfigurationCapability) {
+            config = await this.connection.workspace.getConfiguration({
+                scopeUri: scopeUri,
+                section: section
+            });
         }
+        return config;
+    }
+    /**
+     * Send a critical failure notification to the client, which should show a notification of some kind
+     */
+    sendCriticalFailure(message) {
+        this.connection.sendNotification('critical-failure', message).catch(logAndIgnoreError);
+    }
+    /**
+     * Send diagnostics to the client
+     */
+    async sendDiagnostics(options) {
+        const patch = this.diagnosticCollection.getPatch(options.project.projectNumber, options.diagnostics);
+        await Promise.all(Object.keys(patch).map(async (srcPath) => {
+            const uri = vscode_uri_1.URI.file(srcPath).toString();
+            const diagnostics = patch[srcPath].map(d => util_1.util.toDiagnostic(d, uri));
+            await this.connection.sendDiagnostics({
+                uri: uri,
+                diagnostics: diagnostics
+            });
+        }));
     }
     dispose() {
-        var _a;
+        var _a, _b, _c;
+        clearTimeout(this.fileChangeDebounceTimer);
         (_a = this.loggerSubscription) === null || _a === void 0 ? void 0 : _a.call(this);
-        this.validateThrottler.dispose();
+        (_c = (_b = this.projectManager) === null || _b === void 0 ? void 0 : _b.dispose) === null || _c === void 0 ? void 0 : _c.call(_b);
     }
 }
+/**
+ * The default threading setting for the language server. Can be overridden by per-workspace settings
+ */
+LanguageServer.enableThreadingDefault = true;
+/**
+ * The default project discovery setting for the language server. Can be overridden by per-workspace settings
+ */
+LanguageServer.enableProjectDiscoveryDefault = true;
+/**
+ * The default number of projects that are permitted to activate concurrently.
+ */
+LanguageServer.projectActivationConcurrencyLimitDefault = 3;
 __decorate([
     AddStackToErrorMessage
 ], LanguageServer.prototype, "onInitialize", null);
@@ -913,31 +736,28 @@ __decorate([
 ], LanguageServer.prototype, "onInitialized", null);
 __decorate([
     AddStackToErrorMessage
-], LanguageServer.prototype, "onCompletion", null);
+], LanguageServer.prototype, "onTextDocumentDidChangeContent", null);
 __decorate([
     AddStackToErrorMessage
-], LanguageServer.prototype, "onCompletionResolve", null);
+], LanguageServer.prototype, "onDidChangeWatchedFiles", null);
 __decorate([
     AddStackToErrorMessage
-], LanguageServer.prototype, "onCodeAction", null);
+], LanguageServer.prototype, "onDocumentClose", null);
 __decorate([
     AddStackToErrorMessage
-], LanguageServer.prototype, "onDidChangeConfiguration", null);
+], LanguageServer.prototype, "onCompletion", null);
 __decorate([
     AddStackToErrorMessage
-], LanguageServer.prototype, "onDidChangeWatchedFiles", null);
+], LanguageServer.prototype, "onDidChangeConfiguration", null);
 __decorate([
     AddStackToErrorMessage
 ], LanguageServer.prototype, "onHover", null);
 __decorate([
     AddStackToErrorMessage
-], LanguageServer.prototype, "onDocumentClose", null);
+], LanguageServer.prototype, "onWorkspaceSymbol", null);
 __decorate([
     AddStackToErrorMessage
-], LanguageServer.prototype, "validateTextDocument", null);
-__decorate([
-    AddStackToErrorMessage
-], LanguageServer.prototype, "onWorkspaceSymbol", null);
+], LanguageServer.prototype, "onSelectionRanges", null);
 __decorate([
     AddStackToErrorMessage
 ], LanguageServer.prototype, "onDocumentSymbol", null);
@@ -950,9 +770,15 @@ __decorate([
 __decorate([
     AddStackToErrorMessage
 ], LanguageServer.prototype, "onReferences", null);
+__decorate([
+    AddStackToErrorMessage
+], LanguageServer.prototype, "onWillRenameFiles", null);
 __decorate([
     AddStackToErrorMessage
 ], LanguageServer.prototype, "onFullSemanticTokens", null);
+__decorate([
+    AddStackToErrorMessage
+], LanguageServer.prototype, "onCodeAction", null);
 __decorate([
     AddStackToErrorMessage
 ], LanguageServer.prototype, "onExecuteCommand", null);
@@ -961,6 +787,10 @@ var CustomCommands;
 (function (CustomCommands) {
     CustomCommands["TranspileFile"] = "TranspileFile";
 })(CustomCommands = exports.CustomCommands || (exports.CustomCommands = {}));
+var NotificationName;
+(function (NotificationName) {
+    NotificationName["busyStatus"] = "busyStatus";
+})(NotificationName = exports.NotificationName || (exports.NotificationName = {}));
 /**
  * Wraps a method. If there's an error (either sync or via a promise),
  * this appends the error's stack trace at the end of the error message so that the connection will
@@ -992,4 +822,10 @@ function AddStackToErrorMessage(target, propertyKey, descriptor) {
         }
     };
 }
+function logAndIgnoreError(error) {
+    if (error === null || error === void 0 ? void 0 : error.stack) {
+        error.message = error.stack;
+    }
+    console.error(error);
+}
 //# sourceMappingURL=LanguageServer.js.map