brighterscript 0.51.3 → 0.52.1

package/dist/LanguageServer.js

@@ -8,7 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomCommands = exports.LanguageServer = void 0;
 require("array-flat-polyfill");
-const glob = require("glob");
+const fastGlob = require("fast-glob");
 const path = require("path");
 const roku_deploy_1 = require("roku-deploy");
 const node_1 = require("vscode-languageserver/node");
@@ -27,18 +27,18 @@ const SemanticTokenUtils_1 = require("./SemanticTokenUtils");
 class LanguageServer {
     constructor() {
         this.connection = undefined;
-        this.workspaces = [];
+        this.projects = [];
         /**
          * The number of milliseconds that should be used for language server typing debouncing
          */
         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.
+         * These projects are created on the fly whenever a file is opened that is not included
+         * in any of the workspace-based projects.
+         * Basically these are single-file projects 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.standaloneFileProjects = {};
         this.hasConfigurationCapability = false;
         /**
          * Indicates whether the client supports workspace folders
@@ -77,17 +77,11 @@ class LanguageServer {
         // 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.validateTextDocument.bind(this));
         //whenever a document gets closed
-        this.documents.onDidClose(async (change) => {
-            await this.onDocumentClose(change.document);
-        });
+        this.documents.onDidClose(this.onDocumentClose.bind(this));
         // This handler provides the initial list of the completion items.
-        this.connection.onCompletion(async (params) => {
-            return this.onCompletion(params.textDocument.uri, params.position);
-        });
+        this.connection.onCompletion(this.onCompletion.bind(this));
         // This handler resolves additional information for the item selected in
         // the completion list.
         this.connection.onCompletionResolve(this.onCompletionResolve.bind(this));
@@ -169,42 +163,118 @@ class LanguageServer {
             }
         };
     }
+    /**
+     * Ask the client for the list of `files.exclude` patterns. Useful when determining if we should process a file
+     */
+    async getWorkspaceExcludeGlobs(workspaceFolder) {
+        var _a;
+        //get any `files.exclude` globs to use to filter
+        let config = await this.connection.workspace.getConfiguration({
+            scopeUri: workspaceFolder,
+            section: 'files'
+        });
+        return Object
+            .keys((_a = config === null || config === void 0 ? void 0 : config.exclude) !== null && _a !== void 0 ? _a : {})
+            .filter(x => { var _a; return (_a = config === null || config === void 0 ? void 0 : config.exclude) === null || _a === void 0 ? void 0 : _a[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 => [
+            //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)
+            `${pattern}/**/*`
+        ])
+            .flat(1)
+            .concat([
+            //always ignore projects from node_modules
+            '**/node_modules/**/*'
+        ]);
+    }
+    /**
+     * Scan the workspace for all `bsconfig.json` files. If at least one is found, then only folders who have bsconfig.json are returned.
+     * If none are found, then the workspaceFolder itself is treated as a project
+     */
+    async getProjectPaths(workspaceFolder) {
+        const excludes = (await this.getWorkspaceExcludeGlobs(workspaceFolder)).map(x => (0, util_1.standardizePath) `!${x}`);
+        const files = await roku_deploy_1.rokuDeploy.getFilePaths([
+            '**/bsconfig.json',
+            //exclude all files found in `files.exclude`
+            ...excludes
+        ], workspaceFolder);
+        //if we found at least one bsconfig.json, then ALL projects must have a bsconfig.json.
+        if (files.length > 0) {
+            return files.map(file => (0, util_1.standardizePath) `${path.dirname(file.src)}`);
+        }
+        else {
+            //treat the workspace folder as a brightscript project itself
+            return [workspaceFolder];
+        }
+    }
+    /**
+     * Find all folders with bsconfig.json files in them, and treat each as a project.
+     * Treat workspaces that don't have a bsconfig.json as a project.
+     * Handle situations where bsconfig.json files were added or removed (to elevate/lower workspaceFolder projects accordingly)
+     * Leave existing projects alone if they are not affected by these changes
+     */
+    async syncProjects() {
+        const workspacePaths = await this.getWorkspacePaths();
+        let projectPaths = (await Promise.all(workspacePaths.map(async (workspacePath) => {
+            const projectPaths = await this.getProjectPaths(workspacePath);
+            return projectPaths.map(projectPath => ({
+                projectPath: projectPath,
+                workspacePath: workspacePath
+            }));
+        }))).flat(1);
+        //delete projects not represented in the list
+        for (const project of this.getProjects()) {
+            if (!projectPaths.find(x => x.projectPath === project.projectPath)) {
+                this.removeProject(project);
+            }
+        }
+        //exclude paths to projects we already have
+        projectPaths = projectPaths.filter(x => {
+            //only keep this project path if there's not a project with that path
+            return !this.projects.find(project => project.projectPath === x.projectPath);
+        });
+        //dedupe by project path
+        projectPaths = [
+            ...projectPaths.reduce((acc, x) => acc.set(x.projectPath, x), new Map()).values()
+        ];
+        //create missing projects
+        await Promise.all(projectPaths.map(x => this.createProject(x.projectPath, x.workspacePath)));
+        //flush diagnostics
+        await this.sendDiagnostics();
+    }
+    /**
+     * Get all workspace paths from the client
+     */
+    async getWorkspacePaths() {
+        var _a;
+        let workspaceFolders = (_a = await this.connection.workspace.getWorkspaceFolders()) !== null && _a !== void 0 ? _a : [];
+        return workspaceFolders.map((x) => {
+            return util_1.util.uriToPath(x.uri);
+        });
+    }
     /**
      * Called when the client has finished initializing
      * @param params
      */
     async onInitialized() {
-        var _a;
-        let workspaceCreatedDeferred = new deferred_1.Deferred();
-        this.initialWorkspacesCreated = workspaceCreatedDeferred.promise;
+        let projectCreatedDeferred = new deferred_1.Deferred();
+        this.initialProjectsCreated = projectCreatedDeferred.promise;
         try {
             if (this.hasConfigurationCapability) {
                 // Register for all configuration changes.
                 await this.connection.client.register(node_1.DidChangeConfigurationNotification.type, undefined);
             }
-            //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);
+            await this.syncProjects();
             if (this.clientHasWorkspaceFolderCapability) {
                 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.waitAllProjectFirstRuns(false);
+            projectCreatedDeferred.resolve();
             await this.sendDiagnostics();
         }
         catch (e) {
@@ -224,34 +294,25 @@ class LanguageServer {
     /**
      * Wait for all programs' first run to complete
      */
-    async waitAllProgramFirstRuns(waitForFirstWorkSpace = true) {
+    async waitAllProjectFirstRuns(waitForFirstWorkSpace = true) {
         if (waitForFirstWorkSpace) {
-            await this.initialWorkspacesCreated;
+            await this.initialProjectsCreated;
         }
         let status;
-        let workspaces = this.getWorkspaces();
-        for (let workspace of workspaces) {
+        for (let project of this.getProjects()) {
             try {
-                await workspace.firstRunPromise;
+                await project.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();
+                project.firstRunPromise = Promise.resolve();
                 this.sendCriticalFailure(`BrighterScript language server failed to start: \n${e.message}`);
             }
         }
         this.connection.sendNotification('build-status', status ? status : 'success');
     }
-    /**
-     * Create project for each new workspace. If the workspace is already known,
-     * it is skipped.
-     * @param workspaceFolders
-     */
-    async createWorkspaces(workspacePaths) {
-        return Promise.all(workspacePaths.map(async (workspacePath) => this.createWorkspace(workspacePath)));
-    }
     /**
      * 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
@@ -284,7 +345,7 @@ class LanguageServer {
                 return configFilePath;
             }
             else {
-                this.sendCriticalFailure(`Cannot find config file specified in user/workspace settings at '${configFilePath}'`);
+                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
@@ -300,10 +361,11 @@ class LanguageServer {
         //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) {
+    async createProject(projectPath, workspacePath = projectPath) {
+        workspacePath !== null && workspacePath !== void 0 ? workspacePath : (workspacePath = projectPath);
+        let project = this.projects.find((x) => x.projectPath === projectPath);
+        //skip this project if we already have it
+        if (project) {
             return;
         }
         let builder = new ProgramBuilder_1.ProgramBuilder();
@@ -311,8 +373,8 @@ class LanguageServer {
         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;
+        let configFilePath = await this.getConfigFilePath(projectPath);
+        let cwd = projectPath;
         //if the config file exists, use it and its folder as cwd
         if (configFilePath && await util_1.util.pathExists(configFilePath)) {
             cwd = path.dirname(configFilePath);
@@ -333,22 +395,23 @@ class LanguageServer {
         firstRunPromise.catch((err) => {
             console.error(err);
         });
-        let newWorkspace = {
+        let newProject = {
             builder: builder,
             firstRunPromise: firstRunPromise,
+            projectPath: projectPath,
             workspacePath: workspacePath,
             isFirstRunComplete: false,
             isFirstRunSuccessful: false,
             configFilePath: configFilePath,
-            isStandaloneFileWorkspace: false
+            isStandaloneFileProject: false
         };
-        this.workspaces.push(newWorkspace);
+        this.projects.push(newProject);
         await firstRunPromise.then(() => {
-            newWorkspace.isFirstRunComplete = true;
-            newWorkspace.isFirstRunSuccessful = true;
+            newProject.isFirstRunComplete = true;
+            newProject.isFirstRunSuccessful = true;
         }).catch(() => {
-            newWorkspace.isFirstRunComplete = true;
-            newWorkspace.isFirstRunSuccessful = false;
+            newProject.isFirstRunComplete = true;
+            newProject.isFirstRunSuccessful = false;
         }).then(() => {
             //if we found a deprecated brsconfig.json, add a diagnostic warning the user
             if (configFilePath && path.basename(configFilePath) === 'brsconfig.json') {
@@ -357,10 +420,10 @@ class LanguageServer {
             }
         });
     }
-    async createStandaloneFileWorkspace(srcPath) {
+    async createStandaloneFileProject(srcPath) {
         //skip this workspace if we already have it
-        if (this.standaloneFileWorkspaces[srcPath]) {
-            return this.standaloneFileWorkspaces[srcPath];
+        if (this.standaloneFileProjects[srcPath]) {
+            return this.standaloneFileProjects[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
@@ -387,45 +450,46 @@ class LanguageServer {
             ] })).catch((err) => {
             console.error(err);
         });
-        let newWorkspace = {
+        let newProject = {
             builder: builder,
             firstRunPromise: firstRunPromise,
+            projectPath: srcPath,
             workspacePath: srcPath,
             isFirstRunComplete: false,
             isFirstRunSuccessful: false,
             configFilePath: configFilePath,
-            isStandaloneFileWorkspace: true
+            isStandaloneFileProject: true
         };
-        this.standaloneFileWorkspaces[srcPath] = newWorkspace;
+        this.standaloneFileProjects[srcPath] = newProject;
         await firstRunPromise.then(() => {
-            newWorkspace.isFirstRunComplete = true;
-            newWorkspace.isFirstRunSuccessful = true;
+            newProject.isFirstRunComplete = true;
+            newProject.isFirstRunSuccessful = true;
         }).catch(() => {
-            newWorkspace.isFirstRunComplete = true;
-            newWorkspace.isFirstRunSuccessful = false;
+            newProject.isFirstRunComplete = true;
+            newProject.isFirstRunSuccessful = false;
         });
-        return newWorkspace;
+        return newProject;
     }
-    getWorkspaces() {
-        let workspaces = this.workspaces.slice();
-        for (let key in this.standaloneFileWorkspaces) {
-            workspaces.push(this.standaloneFileWorkspaces[key]);
+    getProjects() {
+        let projects = this.projects.slice();
+        for (let key in this.standaloneFileProjects) {
+            projects.push(this.standaloneFileProjects[key]);
         }
-        return workspaces;
+        return projects;
     }
     /**
      * Provide a list of completion items based on the current cursor position
      * @param textDocumentPosition
      */
-    async onCompletion(uri, position) {
+    async onCompletion(params) {
         //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
-        let filePath = util_1.util.uriToPath(uri);
+        await this.waitAllProjectFirstRuns();
+        let filePath = util_1.util.uriToPath(params.textDocument.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));
+            .getProjects()
+            .flatMap(workspace => workspace.builder.program.getCompletions(filePath, params.position));
         for (let completion of completions) {
             completion.commitCharacters = ['.'];
         }
@@ -448,12 +512,12 @@ class LanguageServer {
     }
     async onCodeAction(params) {
         //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
+        await this.waitAllProjectFirstRuns();
         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()
+            .getProjects()
             //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));
@@ -466,38 +530,42 @@ class LanguageServer {
         return codeActions;
     }
     /**
-     * Reload all specified workspaces, or all workspaces if no workspaces are specified
+     * Remove a project from the language server
+     */
+    removeProject(project) {
+        var _a;
+        const idx = this.projects.indexOf(project);
+        if (idx > -1) {
+            this.projects.splice(idx, 1);
+        }
+        (_a = project === null || project === void 0 ? void 0 : project.builder) === null || _a === void 0 ? void 0 : _a.dispose();
+    }
+    /**
+     * Reload each of the specified workspaces
      */
-    async reloadWorkspaces(workspaces) {
-        workspaces = workspaces ? workspaces : this.getWorkspaces();
-        await Promise.all(workspaces.map(async (workspace) => {
+    async reloadProjects(projects) {
+        await Promise.all(projects.map(async (project) => {
             //ensure the workspace has finished starting up
             try {
-                await workspace.firstRunPromise;
+                await project.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();
-                }
+            if (project.isStandaloneFileProject === false) {
+                this.removeProject(project);
                 //create a new workspace/brs program
-                await this.createWorkspace(workspace.workspacePath);
+                await this.createProject(project.projectPath, project.workspacePath);
                 //handle temp workspace
             }
             else {
-                workspace.builder.dispose();
-                delete this.standaloneFileWorkspaces[workspace.workspacePath];
-                await this.createStandaloneFileWorkspace(workspace.workspacePath);
+                project.builder.dispose();
+                delete this.standaloneFileProjects[project.projectPath];
+                await this.createStandaloneFileProject(project.projectPath);
             }
         }));
-        if (workspaces.length > 0) {
+        if (projects.length > 0) {
             //wait for all of the programs to finish starting up
-            await this.waitAllProgramFirstRuns();
+            await this.waitAllProjectFirstRuns();
             // valdiate all workspaces
             this.validateAllThrottled(); //eslint-disable-line
         }
@@ -514,42 +582,42 @@ class LanguageServer {
      *
      * Sometimes files that used to be included are now excluded, so those open files need to be re-processed as standalone
      */
-    async synchronizeStandaloneWorkspaces() {
+    async synchronizeStandaloneProjects() {
         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 = roku_deploy_1.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));
+        for (let standaloneFilePath in this.standaloneFileProjects) {
+            let standaloneProject = this.standaloneFileProjects[standaloneFilePath];
+            for (let project of this.projects) {
+                await standaloneProject.firstRunPromise;
+                let dest = roku_deploy_1.rokuDeploy.getDestPath(standaloneFilePath, (_d = (_c = (_b = (_a = project === null || project === void 0 ? void 0 : project.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(project));
                 //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];
+                if (((_f = (_e = project === null || project === void 0 ? void 0 : project.builder) === null || _e === void 0 ? void 0 : _e.program) === null || _f === void 0 ? void 0 : _f.hasFile(standaloneFilePath)) || dest) {
+                    standaloneProject.builder.dispose();
+                    delete this.standaloneFileProjects[standaloneFilePath];
                 }
             }
         }
-        //create standalone workspaces for open files that no longer have a project
+        //create standalone projects 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 = roku_deploy_1.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) {
+            for (let project of this.getProjects()) {
+                let dest = roku_deploy_1.rokuDeploy.getDestPath(filePath, (_k = (_j = (_h = (_g = project === null || project === void 0 ? void 0 : project.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(project));
+                //if this project has the file, or it wants the file, do NOT make a standaloneProject for this file
+                if (((_m = (_l = project === null || project === void 0 ? void 0 : project.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;
+            let project = await this.createStandaloneFileProject(filePath);
+            await project.firstRunPromise;
         }
     }
     async onDidChangeConfiguration() {
         if (this.hasConfigurationCapability) {
-            await this.reloadWorkspaces();
+            //if the user changes any config value, just mass-reload all projects
+            await this.reloadProjects(this.getProjects());
             // Reset all cached document settings
         }
         else {
@@ -567,9 +635,9 @@ class LanguageServer {
      */
     async onDidChangeWatchedFiles(params) {
         //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
+        await this.waitAllProjectFirstRuns();
         this.connection.sendNotification('build-status', 'building');
-        let workspaces = this.getWorkspaces();
+        let projects = this.getProjects();
         //convert all file paths to absolute paths
         let changes = params.changes.map(x => {
             return {
@@ -582,23 +650,27 @@ class LanguageServer {
         changes = changes.filter(x => keys.includes(x.srcPath));
         //if we have changes to work with
         if (changes.length > 0) {
+            //if any bsconfig files were added or deleted, re-sync all projects instead of the more specific approach below
+            if (changes.find(x => (x.type === node_1.FileChangeType.Created || x.type === node_1.FileChangeType.Deleted) && path.basename(x.srcPath).toLowerCase() === 'bsconfig.json')) {
+                return this.syncProjects();
+            }
             //reload any workspace whose bsconfig.json file has changed
             {
-                let workspacesToReload = [];
+                let projectsToReload = [];
                 //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);
+                for (let project of projects) {
+                    if (project.configFilePath && filePaths.includes(project.configFilePath)) {
+                        projectsToReload.push(project);
                     }
                 }
-                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);
+                if (projectsToReload.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 project files
+                    //reload any projects that need to be reloaded
+                    await this.reloadProjects(projectsToReload);
                 }
-                //set the list of workspaces to non-reloaded workspaces
-                workspaces = workspaces.filter(x => !workspacesToReload.includes(x));
+                //reassign `projects` to the non-reloaded projects
+                projects = projects.filter(x => !projectsToReload.includes(x));
             }
             //convert created folders into a list of files of their contents
             const directoryChanges = changes
@@ -616,10 +688,10 @@ class LanguageServer {
                 .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 = roku_deploy_1.util.toForwardSlashes(`${dirPath}/**/*`);
-                let files = glob.sync(pattern, {
-                    absolute: true
+                //look up all files
+                let files = fastGlob.sync('**/*', {
+                    absolute: true,
+                    cwd: roku_deploy_1.util.toForwardSlashes(dirPath)
                 });
                 return files.map(x => {
                     return {
@@ -631,7 +703,7 @@ class LanguageServer {
             //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)));
+            await Promise.all(projects.map((project) => this.handleFileChanges(project, changes)));
         }
         this.connection.sendNotification('build-status', 'success');
     }
@@ -640,13 +712,13 @@ class LanguageServer {
      * any file changes you receive with no unexpected side-effects
      * @param changes
      */
-    async handleFileChanges(workspace, changes) {
+    async handleFileChanges(project, 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;
+                consumeCount += await this.handleFileChange(project, change) ? 1 : 0;
             });
         }));
         if (consumeCount > 0) {
@@ -658,14 +730,12 @@ class LanguageServer {
      * any file changes you receive with no unexpected side-effects
      * @param changes
      */
-    async handleFileChange(workspace, change) {
-        const program = workspace.builder.program;
-        const options = workspace.builder.options;
-        const rootDir = workspace.builder.rootDir;
+    async handleFileChange(project, change) {
+        const { program, options, rootDir } = project.builder;
         //deleted
         if (change.type === node_1.FileChangeType.Deleted) {
             //try to act on this path as a directory
-            workspace.builder.removeFilesInFolder(change.srcPath);
+            project.builder.removeFilesInFolder(change.srcPath);
             //if this is a file loaded in the program, remove it
             if (program.hasFile(change.srcPath)) {
                 program.removeFile(change.srcPath);
@@ -685,7 +755,7 @@ class LanguageServer {
                 program.setFile({
                     src: change.srcPath,
                     dest: roku_deploy_1.rokuDeploy.getDestPath(change.srcPath, options.files, rootDir)
-                }, await workspace.builder.getFileContents(change.srcPath));
+                }, await project.builder.getFileContents(change.srcPath));
                 return true;
             }
             else {
@@ -701,7 +771,7 @@ class LanguageServer {
                 program.setFile({
                     src: change.srcPath,
                     dest: roku_deploy_1.rokuDeploy.getDestPath(change.srcPath, options.files, rootDir)
-                }, await workspace.builder.getFileContents(change.srcPath));
+                }, await project.builder.getFileContents(change.srcPath));
             }
             else {
                 program.removeFile(change.srcPath);
@@ -711,75 +781,77 @@ class LanguageServer {
     }
     async onHover(params) {
         //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
+        await this.waitAllProjectFirstRuns();
         const 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))));
+        let projects = this.getProjects();
+        let hovers = await Promise.all(Array.prototype.concat.call([], projects.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];
         return hover;
     }
-    async onDocumentClose(textDocument) {
-        let filePath = vscode_uri_1.URI.parse(textDocument.uri).fsPath;
-        let standaloneFileWorkspace = this.standaloneFileWorkspaces[filePath];
+    async onDocumentClose(event) {
+        const { document } = event;
+        let filePath = vscode_uri_1.URI.parse(document.uri).fsPath;
+        let standaloneFileProject = this.standaloneFileProjects[filePath];
         //if this was a temp file, close it
-        if (standaloneFileWorkspace) {
-            await standaloneFileWorkspace.firstRunPromise;
-            standaloneFileWorkspace.builder.dispose();
-            delete this.standaloneFileWorkspaces[filePath];
+        if (standaloneFileProject) {
+            await standaloneFileProject.firstRunPromise;
+            standaloneFileProject.builder.dispose();
+            delete this.standaloneFileProjects[filePath];
             await this.sendDiagnostics();
         }
     }
-    async validateTextDocument(textDocument) {
+    async validateTextDocument(event) {
+        const { document } = event;
         //ensure programs are initialized
-        await this.waitAllProgramFirstRuns();
-        let filePath = vscode_uri_1.URI.parse(textDocument.uri).fsPath;
+        await this.waitAllProjectFirstRuns();
+        let filePath = vscode_uri_1.URI.parse(document.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()) {
+                let documentText = document.getText();
+                for (const project of this.getProjects()) {
                     //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 = roku_deploy_1.rokuDeploy.getDestPath(filePath, workspace.builder.program.options.files, rootDir);
-                        workspace.builder.program.setFile({
+                    if (project.builder.program.hasFile(filePath)) {
+                        let rootDir = (_a = project.builder.program.options.rootDir) !== null && _a !== void 0 ? _a : project.builder.program.options.cwd;
+                        let dest = roku_deploy_1.rokuDeploy.getDestPath(filePath, project.builder.program.options.files, rootDir);
+                        project.builder.program.setFile({
                             src: filePath,
                             dest: dest
                         }, documentText);
                     }
                 }
             });
-            // validate all workspaces
+            // validate all projects
             await this.validateAllThrottled();
         }
         catch (e) {
-            this.sendCriticalFailure(`Critical error parsing/ validating ${filePath}: ${e.message}`);
+            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();
+            await this.synchronizeStandaloneProjects();
+            let projects = this.getProjects();
             //validate all programs
-            await Promise.all(workspaces.map((x) => x.builder.program.validate()));
+            await Promise.all(projects.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.sendCriticalFailure(`Critical error validating project: ${e.message}${(_a = e.stack) !== null && _a !== void 0 ? _a : ''}`);
         }
         this.connection.sendNotification('build-status', 'success');
     }
     async onWorkspaceSymbol(params) {
-        await this.waitAllProgramFirstRuns();
-        const results = util_1.util.flatMap(await Promise.all(this.getWorkspaces().map(workspace => {
-            return workspace.builder.program.getWorkspaceSymbols();
+        await this.waitAllProjectFirstRuns();
+        const results = util_1.util.flatMap(await Promise.all(this.getProjects().map(project => {
+            return project.builder.program.getWorkspaceSymbols();
         })), c => c);
         // Remove duplicates
         const allSymbols = Object.values(results.reduce((map, symbol) => {
@@ -790,31 +862,31 @@ class LanguageServer {
         return allSymbols;
     }
     async onDocumentSymbol(params) {
-        await this.waitAllProgramFirstRuns();
+        await this.waitAllProjectFirstRuns();
         await this.keyedThrottler.onIdleOnce(util_1.util.uriToPath(params.textDocument.uri), true);
         const srcPath = util_1.util.uriToPath(params.textDocument.uri);
-        for (const workspace of this.getWorkspaces()) {
-            const file = workspace.builder.program.getFile(srcPath);
+        for (const project of this.getProjects()) {
+            const file = project.builder.program.getFile(srcPath);
             if ((0, reflection_1.isBrsFile)(file)) {
                 return file.getDocumentSymbols();
             }
         }
     }
     async onDefinition(params) {
-        await this.waitAllProgramFirstRuns();
+        await this.waitAllProjectFirstRuns();
         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);
+        const results = util_1.util.flatMap(await Promise.all(this.getProjects().map(project => {
+            return project.builder.program.getDefinition(srcPath, params.position);
         })), c => c);
         return results;
     }
     async onSignatureHelp(params) {
         var _a, _b, _c;
-        await this.waitAllProgramFirstRuns();
+        await this.waitAllProjectFirstRuns();
         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 signatures = util_1.util.flatMap(await Promise.all(this.getProjects().map(project => project.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 = {
@@ -834,22 +906,22 @@ class LanguageServer {
         }
     }
     async onReferences(params) {
-        await this.waitAllProgramFirstRuns();
+        await this.waitAllProjectFirstRuns();
         const position = params.position;
         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);
+        const results = util_1.util.flatMap(await Promise.all(this.getProjects().map(project => {
+            return project.builder.program.getReferences(srcPath, position);
         })), c => c);
         return results.filter((r) => r);
     }
     async onFullSemanticTokens(params) {
-        await this.waitAllProgramFirstRuns();
+        await this.waitAllProjectFirstRuns();
         await this.keyedThrottler.onIdleOnce(util_1.util.uriToPath(params.textDocument.uri), true);
         const srcPath = util_1.util.uriToPath(params.textDocument.uri);
-        for (const workspace of this.workspaces) {
+        for (const project of this.projects) {
             //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);
+            if (project.builder.program.hasFile(srcPath)) {
+                let semanticTokens = project.builder.program.getSemanticTokens(srcPath);
                 return {
                     data: (0, SemanticTokenUtils_1.encodeSemanticTokens)(semanticTokens)
                 };
@@ -858,7 +930,7 @@ class LanguageServer {
     }
     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);
+        const patch = await this.diagnosticCollection.getPatch(this.projects);
         for (let filePath in patch) {
             const diagnostics = patch[filePath].map(d => util_1.util.toDiagnostic(d));
             this.connection.sendDiagnostics({
@@ -868,7 +940,7 @@ class LanguageServer {
         }
     }
     async onExecuteCommand(params) {
-        await this.waitAllProgramFirstRuns();
+        await this.waitAllProjectFirstRuns();
         if (params.command === CustomCommands.TranspileFile) {
             const result = await this.transpileFile(params.arguments[0]);
             //back-compat: include `pathAbsolute` property so older vscode versions still work
@@ -877,12 +949,11 @@ class LanguageServer {
     }
     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);
+        await this.waitAllProjectFirstRuns();
+        //find the first project that has this file
+        for (let project of this.getProjects()) {
+            if (project.builder.program.hasFile(srcPath)) {
+                return project.builder.program.getTranspiledFileContents(srcPath);
             }
         }
     }