brighterscript 1.0.0-alpha.3 → 1.0.0-alpha.31

package/dist/Program.js

@@ -4,35 +4,58 @@ exports.Program = void 0;
 const assert = require("assert");
 const fsExtra = require("fs-extra");
 const path = require("path");
-const vscode_languageserver_1 = require("vscode-languageserver");
 const Scope_1 = require("./Scope");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
-const BrsFile_1 = require("./files/BrsFile");
-const XmlFile_1 = require("./files/XmlFile");
 const util_1 = require("./util");
 const XmlScope_1 = require("./XmlScope");
-const DiagnosticFilterer_1 = require("./DiagnosticFilterer");
 const DependencyGraph_1 = require("./DependencyGraph");
-const Logger_1 = require("./Logger");
+const logging_1 = require("./logging");
 const chalk_1 = require("chalk");
 const globalCallables_1 = require("./globalCallables");
 const Manifest_1 = require("./preprocessor/Manifest");
 const vscode_uri_1 = require("vscode-uri");
 const PluginInterface_1 = require("./PluginInterface");
 const reflection_1 = require("./astUtils/reflection");
-const parser_1 = require("./parser");
-const lexer_1 = require("./lexer");
 const BscPlugin_1 = require("./bscPlugin/BscPlugin");
+const Editor_1 = require("./astUtils/Editor");
+const CallExpressionInfo_1 = require("./bscPlugin/CallExpressionInfo");
+const SignatureHelpUtil_1 = require("./bscPlugin/SignatureHelpUtil");
+const IntegerType_1 = require("./types/IntegerType");
+const StringType_1 = require("./types/StringType");
+const BooleanType_1 = require("./types/BooleanType");
+const DoubleType_1 = require("./types/DoubleType");
+const DynamicType_1 = require("./types/DynamicType");
+const FloatType_1 = require("./types/FloatType");
+const LongIntegerType_1 = require("./types/LongIntegerType");
+const ObjectType_1 = require("./types/ObjectType");
+const VoidType_1 = require("./types/VoidType");
+const FunctionType_1 = require("./types/FunctionType");
+const Factory_1 = require("./files/Factory");
+const ActionPipeline_1 = require("./ActionPipeline");
+const LazyFileData_1 = require("./files/LazyFileData");
 const roku_deploy_1 = require("roku-deploy");
-const bslibNonAliasedRokuModulesPkgPath = `pkg:/source/roku_modules/rokucommunity_bslib/bslib.brs`;
-const bslibAliasedRokuModulesPkgPath = `pkg:/source/roku_modules/bslib/bslib.brs`;
+const roku_types_1 = require("./roku-types");
+const ComponentType_1 = require("./types/ComponentType");
+const InterfaceType_1 = require("./types/InterfaceType");
+const BuiltInInterfaceAdder_1 = require("./types/BuiltInInterfaceAdder");
+const visitors_1 = require("./astUtils/visitors");
+const Stopwatch_1 = require("./Stopwatch");
+const thenby_1 = require("thenby");
+const CrossScopeValidator_1 = require("./CrossScopeValidator");
+const DiagnosticManager_1 = require("./DiagnosticManager");
+const ProgramValidator_1 = require("./bscPlugin/validation/ProgramValidator");
+const bslibNonAliasedRokuModulesPkgPath = (0, util_1.standardizePath) `source/roku_modules/rokucommunity_bslib/bslib.brs`;
+const bslibAliasedRokuModulesPkgPath = (0, util_1.standardizePath) `source/roku_modules/bslib/bslib.brs`;
 class Program {
     constructor(
     /**
      * The root directory for this program
      */
-    options, logger, plugins) {
-        this.options = options;
+    options, logger, plugins, diagnosticsManager) {
+        /**
+         * An editor that plugins can use to modify program-level things during the build flow. Don't use this to edit files (they have their own `.editor`)
+         */
+        this.editor = new Editor_1.Editor();
         /**
          * A graph of all files and their dependencies.
          * For example:
@@ -40,20 +63,26 @@ class Program {
          *      lib2.brs -> [lib3.brs] //via an import statement
          */
         this.dependencyGraph = new DependencyGraph_1.DependencyGraph();
-        this.diagnosticFilterer = new DiagnosticFilterer_1.DiagnosticFilterer();
         /**
-         * A set of diagnostics. This does not include any of the scope diagnostics.
-         * Should only be set from `this.validate()`
+         * A scope that contains all built-in global functions.
+         * All scopes should directly or indirectly inherit from this scope
          */
-        this.diagnostics = [];
+        this.globalScope = undefined;
+        this.fileSymbolInformation = new Map();
         /**
-         * A map of every file loaded ino this program, indexed by its lower-case pkgPath
+         * A map of every file loaded into this program, indexed by its original file location
          */
-        this.pkgMap = {};
+        this.files = {};
         /**
-         * A map of every file loaded into this program, indexed by its lower-case srcPath
+         * A map of every file loaded into this program, indexed by its destPath
          */
-        this.files = {};
+        this.destMap = new Map();
+        /**
+         * Plugins can contribute multiple virtual files for a single physical file.
+         * This collection links the virtual files back to the physical file that produced them.
+         * The key is the standardized and lower-cased srcPath
+         */
+        this.fileClusters = new Map();
         this.scopes = {};
         /**
          * A map of every component currently loaded into the program, indexed by the component name.
@@ -62,28 +91,121 @@ class Program {
          * but if you do, only ever use the component at index 0.
          */
         this.components = {};
+        /**
+         * Keeps a set of all the components that need to have their types updated during the current validation cycle
+         */
+        this.componentSymbolsToUpdate = new Set();
+        this.crossScopeValidation = new CrossScopeValidator_1.CrossScopeValidator(this);
+        this.isFirstValidation = true;
+        this.getTranspiledFileContentsPipeline = new ActionPipeline_1.ActionPipeline();
+        this.buildPipeline = new ActionPipeline_1.ActionPipeline();
         this.options = util_1.util.normalizeConfig(options);
-        this.logger = logger || new Logger_1.Logger(options.logLevel);
-        this.plugins = plugins || new PluginInterface_1.default([], this.logger);
+        this.logger = logger !== null && logger !== void 0 ? logger : (0, logging_1.createLogger)(options);
+        this.plugins = plugins || new PluginInterface_1.default([], { logger: this.logger });
+        this.diagnostics = diagnosticsManager || new DiagnosticManager_1.DiagnosticManager();
+        // initialize teh diagnostics Manager
+        this.diagnostics.logger = this.logger;
+        this.diagnostics.options = this.options;
         //inject the bsc plugin as the first plugin in the stack.
         this.plugins.addFirst(new BscPlugin_1.BscPlugin());
         //normalize the root dir path
         this.options.rootDir = util_1.util.getRootDir(this.options);
         this.createGlobalScope();
+        this.fileFactory = new Factory_1.FileFactory(this);
     }
     createGlobalScope() {
         //create the 'global' scope
         this.globalScope = new Scope_1.Scope('global', this, 'scope:global');
         this.globalScope.attachDependencyGraph(this.dependencyGraph);
         this.scopes.global = this.globalScope;
+        this.populateGlobalSymbolTable();
         //hardcode the files list for global scope to only contain the global file
         this.globalScope.getAllFiles = () => [globalCallables_1.globalFile];
+        globalCallables_1.globalFile.isValidated = true;
         this.globalScope.validate();
-        //for now, disable validation of global scope because the global files have some duplicate method declarations
-        this.globalScope.getDiagnostics = () => [];
         //TODO we might need to fix this because the isValidated clears stuff now
         this.globalScope.isValidated = true;
     }
+    recursivelyAddNodeToSymbolTable(nodeData) {
+        if (!nodeData) {
+            return;
+        }
+        let nodeType;
+        const nodeName = util_1.util.getSgNodeTypeName(nodeData.name);
+        if (!this.globalScope.symbolTable.hasSymbol(nodeName, 2 /* SymbolTypeFlag.typetime */)) {
+            let parentNode;
+            if (nodeData.extends) {
+                const parentNodeData = roku_types_1.nodes[nodeData.extends.name.toLowerCase()];
+                try {
+                    parentNode = this.recursivelyAddNodeToSymbolTable(parentNodeData);
+                }
+                catch (error) {
+                    this.logger.error(error, nodeData);
+                }
+            }
+            nodeType = new ComponentType_1.ComponentType(nodeData.name, parentNode);
+            nodeType.addBuiltInInterfaces();
+            if (nodeData.name === 'Node') {
+                // Add `roSGNode` as shorthand for `roSGNodeNode`
+                this.globalScope.symbolTable.addSymbol('roSGNode', { description: nodeData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+            }
+            this.globalScope.symbolTable.addSymbol(nodeName, { description: nodeData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+        }
+        else {
+            nodeType = this.globalScope.symbolTable.getSymbolType(nodeName, { flags: 2 /* SymbolTypeFlag.typetime */ });
+        }
+        return nodeType;
+    }
+    /**
+     * Do all setup required for the global symbol table.
+     */
+    populateGlobalSymbolTable() {
+        //Setup primitive types in global symbolTable
+        this.globalScope.symbolTable.addSymbol('boolean', undefined, BooleanType_1.BooleanType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('double', undefined, DoubleType_1.DoubleType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('dynamic', undefined, DynamicType_1.DynamicType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('float', undefined, FloatType_1.FloatType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('function', undefined, new FunctionType_1.FunctionType(), 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('integer', undefined, IntegerType_1.IntegerType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('longinteger', undefined, LongIntegerType_1.LongIntegerType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('object', undefined, new ObjectType_1.ObjectType(), 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('string', undefined, StringType_1.StringType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('void', undefined, VoidType_1.VoidType.instance, 2 /* SymbolTypeFlag.typetime */);
+        BuiltInInterfaceAdder_1.BuiltInInterfaceAdder.getLookupTable = () => this.globalScope.symbolTable;
+        for (const callable of globalCallables_1.globalCallables) {
+            this.globalScope.symbolTable.addSymbol(callable.name, { description: callable.shortDescription }, callable.type, 1 /* SymbolTypeFlag.runtime */);
+        }
+        for (const ifaceData of Object.values(roku_types_1.interfaces)) {
+            const nodeType = new InterfaceType_1.InterfaceType(ifaceData.name);
+            nodeType.addBuiltInInterfaces();
+            this.globalScope.symbolTable.addSymbol(ifaceData.name, { description: ifaceData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+        }
+        for (const componentData of Object.values(roku_types_1.components)) {
+            const nodeType = new InterfaceType_1.InterfaceType(componentData.name);
+            nodeType.addBuiltInInterfaces();
+            if (componentData.name !== 'roSGNode') {
+                // we will add `roSGNode` as shorthand for `roSGNodeNode`, since all roSgNode components are SceneGraph nodes
+                this.globalScope.symbolTable.addSymbol(componentData.name, { description: componentData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+            }
+        }
+        for (const nodeData of Object.values(roku_types_1.nodes)) {
+            this.recursivelyAddNodeToSymbolTable(nodeData);
+        }
+        for (const eventData of Object.values(roku_types_1.events)) {
+            const nodeType = new InterfaceType_1.InterfaceType(eventData.name);
+            nodeType.addBuiltInInterfaces();
+            this.globalScope.symbolTable.addSymbol(eventData.name, { description: eventData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+        }
+    }
+    addFileSymbolInfo(file) {
+        this.fileSymbolInformation.set(file.pkgPath, {
+            provides: file.providedSymbols,
+            requires: file.requiredSymbols
+        });
+    }
+    getFileSymbolInfo(file) {
+        return this.fileSymbolInformation.get(file.pkgPath);
+    }
     /**
      * The path to bslib.brs (the BrightScript runtime for certain BrighterScript features)
      */
@@ -98,7 +220,7 @@ class Program {
             //default to the embedded version
         }
         else {
-            return `pkg:/source/bslib.brs`;
+            return `${this.options.bslibDestinationDir}${path.sep}bslib.brs`;
         }
     }
     get bslibPrefix() {
@@ -109,18 +231,8 @@ class Program {
             return 'bslib';
         }
     }
-    /**
-     * Get a copy of the list of files currently loaded in the program
-     */
-    getFiles() {
-        return Object.values(this.files);
-    }
     addScope(scope) {
         this.scopes[scope.name] = scope;
-        this.plugins.emit('afterScopeCreate', {
-            program: this,
-            scope: scope
-        });
     }
     /**
      * Get the component with the specified name
@@ -129,19 +241,34 @@ class Program {
         var _a;
         if (componentName) {
             //return the first compoment in the list with this name
-            //(components are ordered in this list by pkgPath to ensure consistency)
+            //(components are ordered in this list by destPath to ensure consistency)
             return (_a = this.components[componentName.toLowerCase()]) === null || _a === void 0 ? void 0 : _a[0];
         }
         else {
             return undefined;
         }
     }
+    /**
+     * Get the sorted names of custom components
+     */
+    getSortedComponentNames() {
+        const componentNames = Object.keys(this.components);
+        componentNames.sort((a, b) => {
+            if (a < b) {
+                return -1;
+            }
+            else if (b < a) {
+                return 1;
+            }
+            return 0;
+        });
+        return componentNames;
+    }
     /**
      * Register (or replace) the reference to a component in the component map
      */
     registerComponent(xmlFile, scope) {
-        var _a, _b;
-        const key = ((_b = (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : xmlFile.pkgPath).toLowerCase();
+        const key = this.getComponentKey(xmlFile);
         if (!this.components[key]) {
             this.components[key] = [];
         }
@@ -149,15 +276,25 @@ class Program {
             file: xmlFile,
             scope: scope
         });
-        this.components[key].sort((x, y) => x.file.pkgPath.toLowerCase().localeCompare(y.file.pkgPath.toLowerCase()));
+        this.components[key].sort((a, b) => {
+            const pathA = a.file.destPath.toLowerCase();
+            const pathB = b.file.destPath.toLowerCase();
+            if (pathA < pathB) {
+                return -1;
+            }
+            else if (pathA > pathB) {
+                return 1;
+            }
+            return 0;
+        });
         this.syncComponentDependencyGraph(this.components[key]);
+        this.addDeferredComponentTypeSymbolCreation(xmlFile);
     }
     /**
      * Remove the specified component from the components map
      */
     unregisterComponent(xmlFile) {
-        var _a, _b;
-        const key = ((_b = (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : xmlFile.pkgPath).toLowerCase();
+        const key = this.getComponentKey(xmlFile);
         const arr = this.components[key] || [];
         for (let i = 0; i < arr.length; i++) {
             if (arr[i].file === xmlFile) {
@@ -166,6 +303,44 @@ class Program {
             }
         }
         this.syncComponentDependencyGraph(arr);
+        this.addDeferredComponentTypeSymbolCreation(xmlFile);
+    }
+    /**
+     * Adds a component described in an XML to the set of components that needs to be updated this validation cycle.
+     * @param xmlFile XML file with <component> tag
+     */
+    addDeferredComponentTypeSymbolCreation(xmlFile) {
+        var _a;
+        this.componentSymbolsToUpdate.add({ componentKey: this.getComponentKey(xmlFile), componentName: (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text });
+    }
+    getComponentKey(xmlFile) {
+        var _a, _b;
+        return ((_b = (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : xmlFile.pkgPath).toLowerCase();
+    }
+    /**
+     * Updates the global symbol table with the first component in this.components to have the same name as the component in the file
+     * @param componentKey key getting a component from `this.components`
+     * @param componentName the unprefixed name of the component that will be added (e.g. 'MyLabel' NOT 'roSgNodeMyLabel')
+     */
+    updateComponentSymbolInGlobalScope(componentKey, componentName) {
+        const symbolName = componentName ? util_1.util.getSgNodeTypeName(componentName) : undefined;
+        if (!symbolName) {
+            return;
+        }
+        const components = this.components[componentKey] || [];
+        // Remove any existing symbols that match
+        this.globalScope.symbolTable.removeSymbol(symbolName);
+        // There is a component that can be added - use it.
+        if (components.length > 0) {
+            const componentScope = components[0].scope;
+            // TODO: May need to link symbol tables to get correct types for callfuncs
+            // componentScope.linkSymbolTable();
+            const componentType = componentScope.getComponentType();
+            if (componentType) {
+                this.globalScope.symbolTable.addSymbol(symbolName, {}, componentType, 2 /* SymbolTypeFlag.typetime */);
+            }
+            // TODO: Remember to unlink! componentScope.unlinkSymbolTable();
+        }
     }
     /**
      * re-attach the dependency graph with a new key for any component who changed
@@ -179,6 +354,7 @@ class Program {
             //attach (or re-attach) the dependencyGraph for every component whose position changed
             if (file.dependencyGraphIndex !== i) {
                 file.dependencyGraphIndex = i;
+                this.dependencyGraph.addOrReplace(file.dependencyGraphKey, file.dependencies);
                 file.attachDependencyGraph(this.dependencyGraph);
                 scope.attachDependencyGraph(this.dependencyGraph);
             }
@@ -190,9 +366,10 @@ class Program {
      */
     getUnreferencedFiles() {
         let result = [];
-        for (let key in this.files) {
-            const file = this.files[key];
-            if (!this.fileIsIncludedInAnyScope(file)) {
+        for (let filePath in this.files) {
+            let file = this.files[filePath];
+            //is this file part of a scope
+            if (!this.getFirstScopeForFile(file)) {
                 //no scopes reference this file. add it to the list
                 result.push(file);
             }
@@ -200,37 +377,14 @@ class Program {
         return result;
     }
     /**
-     * Get the list of errors for the entire program. It's calculated on the fly
-     * by walking through every file, so call this sparingly.
+     * Get the list of errors for the entire program.
      */
     getDiagnostics() {
-        return this.logger.time(Logger_1.LogLevel.info, ['Program.getDiagnostics()'], () => {
-            let diagnostics = [...this.diagnostics];
-            //get the diagnostics from all scopes
-            for (let scopeName in this.scopes) {
-                let scope = this.scopes[scopeName];
-                diagnostics.push(...scope.getDiagnostics());
-            }
-            //get the diagnostics from all unreferenced files
-            let unreferencedFiles = this.getUnreferencedFiles();
-            for (let file of unreferencedFiles) {
-                diagnostics.push(...file.getDiagnostics());
-            }
-            const filteredDiagnostics = this.logger.time(Logger_1.LogLevel.debug, ['filter diagnostics'], () => {
-                //filter out diagnostics based on our diagnostic filters
-                let finalDiagnostics = this.diagnosticFilterer.filter(Object.assign(Object.assign({}, this.options), { rootDir: this.options.rootDir }), diagnostics);
-                return finalDiagnostics;
-            });
-            this.logger.info(`diagnostic counts: total=${chalk_1.default.yellow(diagnostics.length.toString())}, after filter=${chalk_1.default.yellow(filteredDiagnostics.length.toString())}`);
-            return filteredDiagnostics;
-        });
-    }
-    addDiagnostics(diagnostics) {
-        this.diagnostics.push(...diagnostics);
+        return this.diagnostics.getDiagnostics();
     }
     /**
      * Determine if the specified file is loaded in this program right now.
-     * @param filePath
+     * @param filePath the absolute or relative path to the file
      * @param normalizePath should the provided path be normalized before use
      */
     hasFile(filePath, normalizePath = true) {
@@ -238,12 +392,15 @@ class Program {
     }
     /**
      * roku filesystem is case INsensitive, so find the scope by key case insensitive
-     * @param scopeName
+     * @param scopeName xml scope names are their `destPath`. Source scope is stored with the key `"source"`
      */
     getScopeByName(scopeName) {
         if (!scopeName) {
             return undefined;
         }
+        //most scopes are xml file pkg paths. however, the ones that are not are single names like "global" and "scope",
+        //so it's safe to run the standardizePkgPath method
+        scopeName = (0, util_1.standardizePath) `${scopeName}`;
         let key = Object.keys(this.scopes).find(x => x.toLowerCase() === scopeName.toLowerCase());
         return this.scopes[key];
     }
@@ -264,113 +421,170 @@ class Program {
      * Update internal maps with this file reference
      */
     assignFile(file) {
+        const fileAddEvent = {
+            file: file,
+            program: this
+        };
+        this.plugins.emit('beforeFileAdd', fileAddEvent);
         this.files[file.srcPath.toLowerCase()] = file;
-        this.pkgMap[file.pkgPath.toLowerCase()] = file;
+        this.destMap.set(file.destPath.toLowerCase(), file);
+        this.plugins.emit('afterFileAdd', fileAddEvent);
+        return file;
     }
     /**
      * Remove this file from internal maps
      */
     unassignFile(file) {
         delete this.files[file.srcPath.toLowerCase()];
-        delete this.pkgMap[file.pkgPath.toLowerCase()];
+        this.destMap.delete(file.destPath.toLowerCase());
+        return file;
     }
-    setFile(fileParam, fileContents) {
-        assert.ok(fileParam, 'fileParam is required');
-        let srcPath;
-        let pkgPath;
-        if (typeof fileParam === 'string') {
-            //is a pkg path
-            if (fileParam.startsWith('pkg:/')) {
-                //srcPath is the pkgPath relative to the rootDir
-                srcPath = util_1.standardizePath `${this.options.rootDir}/${fileParam.substring(5)}`;
-                pkgPath = fileParam;
-                //is a srcPath (absolute path to src file location)
+    setFile(fileParam, fileData) {
+        //normalize the file paths
+        const { srcPath, destPath } = this.getPaths(fileParam, this.options.rootDir);
+        let file = this.logger.time(logging_1.LogLevel.debug, ['Program.setFile()', chalk_1.default.green(srcPath)], () => {
+            var _a, _b, _c;
+            //if the file is already loaded, remove it
+            if (this.hasFile(srcPath)) {
+                this.removeFile(srcPath, true, true);
             }
-            else if (path.isAbsolute(fileParam)) {
-                srcPath = util_1.util.standardizePath(fileParam);
-                //assume the file path is a sub path of rootDir
-                pkgPath = util_1.util.sanitizePkgPath(roku_deploy_1.util.stringReplaceInsensitive(srcPath, this.options.rootDir, ''));
-                //is destPath (path relative to rootDir and `pkg:/`)
+            const data = new LazyFileData_1.LazyFileData(fileData);
+            const event = new ProvideFileEventInternal(this, srcPath, destPath, data, this.fileFactory);
+            this.plugins.emit('beforeProvideFile', event);
+            this.plugins.emit('provideFile', event);
+            this.plugins.emit('afterProvideFile', event);
+            //if no files were provided, create a AssetFile to represent it.
+            if (event.files.length === 0) {
+                event.files.push(this.fileFactory.AssetFile({
+                    srcPath: event.srcPath,
+                    destPath: event.destPath,
+                    pkgPath: event.destPath,
+                    data: data
+                }));
             }
-            else {
-                srcPath = util_1.standardizePath `${this.options.rootDir}/${fileParam}`;
-                pkgPath = util_1.util.sanitizePkgPath(fileParam);
+            //find the file instance for the srcPath that triggered this action.
+            const primaryFile = event.files.find(x => x.srcPath === srcPath);
+            if (!primaryFile) {
+                throw new Error(`No file provided for srcPath '${srcPath}'. Instead, received ${JSON.stringify(event.files.map(x => ({
+                    type: x.type,
+                    srcPath: x.srcPath,
+                    destPath: x.destPath
+                })))}`);
+            }
+            //link the virtual files to the primary file
+            this.fileClusters.set((_a = primaryFile.srcPath) === null || _a === void 0 ? void 0 : _a.toLowerCase(), event.files);
+            for (const file of event.files) {
+                file.srcPath = (0, util_1.standardizePath)(file.srcPath);
+                if (file.destPath) {
+                    file.destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(file.destPath, this.options.rootDir, '')}`;
+                }
+                if (file.pkgPath) {
+                    file.pkgPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(file.pkgPath, this.options.rootDir, '')}`;
+                }
+                else {
+                    file.pkgPath = file.destPath;
+                }
+                file.excludeFromOutput = file.excludeFromOutput === true;
+                //set the dependencyGraph key for every file to its destPath
+                file.dependencyGraphKey = file.destPath.toLowerCase();
+                this.assignFile(file);
+                //register a callback anytime this file's dependencies change
+                if (typeof file.onDependenciesChanged === 'function') {
+                    (_b = file.disposables) !== null && _b !== void 0 ? _b : (file.disposables = []);
+                    file.disposables.push(this.dependencyGraph.onchange(file.dependencyGraphKey, file.onDependenciesChanged.bind(file)));
+                }
+                //register this file (and its dependencies) with the dependency graph
+                this.dependencyGraph.addOrReplace(file.dependencyGraphKey, (_c = file.dependencies) !== null && _c !== void 0 ? _c : []);
+                //if this is a `source` file, add it to the source scope's dependency list
+                if (this.isSourceBrsFile(file)) {
+                    this.createSourceScope();
+                    this.dependencyGraph.addDependency('scope:source', file.dependencyGraphKey);
+                }
+                //if this is an xml file in the components folder, register it as a component
+                if (this.isComponentsXmlFile(file)) {
+                    //create a new scope for this xml file
+                    let scope = new XmlScope_1.XmlScope(file, this);
+                    this.addScope(scope);
+                    //register this compoent now that we have parsed it and know its component name
+                    this.registerComponent(file, scope);
+                    //notify plugins that the scope is created and the component is registered
+                    this.plugins.emit('afterScopeCreate', {
+                        program: this,
+                        scope: scope
+                    });
+                }
             }
-            //is a FileObj
+            return primaryFile;
+        });
+        return file;
+    }
+    /**
+     * Given a srcPath, a destPath, or both, resolve whichever is missing, relative to rootDir.
+     * @param fileParam an object representing file paths
+     * @param rootDir must be a pre-normalized path
+     */
+    getPaths(fileParam, rootDir) {
+        let srcPath;
+        let destPath;
+        assert.ok(fileParam, 'fileParam is required');
+        //lift the path vars from the incoming param
+        if (typeof fileParam === 'string') {
+            fileParam = this.removePkgPrefix(fileParam);
+            srcPath = (0, util_1.standardizePath) `${path.resolve(rootDir, fileParam)}`;
+            destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
         }
         else {
-            srcPath = util_1.standardizePath `${fileParam.src}`;
-            pkgPath = util_1.util.sanitizePkgPath(fileParam.dest);
-        }
-        const lowerPkgPath = pkgPath.toLowerCase();
-        return this.logger.time(Logger_1.LogLevel.debug, ['Program.addOrReplaceFile()', chalk_1.default.green(srcPath)], () => {
-            assert.ok(srcPath, 'srcPath is required');
-            assert.ok(pkgPath, 'pkgPath is required');
-            //if the file is already loaded, remove it
-            if (this.hasFile(srcPath)) {
-                this.removeFile(srcPath);
+            let param = fileParam;
+            if (param.src) {
+                srcPath = (0, util_1.standardizePath) `${param.src}`;
             }
-            let fileExtension = path.extname(srcPath).toLowerCase();
-            let file;
-            const beforeFileParseEvent = {
-                program: this,
-                srcPath: srcPath,
-                source: fileContents
-            };
-            if (fileExtension === '.brs' || fileExtension === '.bs') {
-                let brsFile = new BrsFile_1.BrsFile(srcPath, pkgPath, this);
-                //add file to the `source` dependency list
-                if (brsFile.pkgPath.startsWith('pkg:/source/')) {
-                    this.createSourceScope();
-                    this.dependencyGraph.addDependency('scope:source', brsFile.dependencyGraphKey);
-                }
-                //add the file to the program
-                this.assignFile(brsFile);
-                this.plugins.emit('beforeFileParse', beforeFileParseEvent);
-                this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
-                    brsFile.parse(beforeFileParseEvent.source);
-                });
-                file = brsFile;
-                brsFile.attachDependencyGraph(this.dependencyGraph);
-                this.plugins.emit('afterFileParse', {
-                    program: this,
-                    file: brsFile
-                });
+            if (param.srcPath) {
+                srcPath = (0, util_1.standardizePath) `${param.srcPath}`;
             }
-            else if (
-            //is xml file
-            fileExtension === '.xml' &&
-                //resides in the components folder (Roku will only parse xml files in the components folder)
-                lowerPkgPath.startsWith('pkg:/components/')) {
-                let xmlFile = new XmlFile_1.XmlFile(srcPath, pkgPath, this);
-                this.assignFile(xmlFile);
-                //add the file to the program
-                this.plugins.emit('beforeFileParse', beforeFileParseEvent);
-                this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
-                    xmlFile.parse(beforeFileParseEvent.source);
-                });
-                file = xmlFile;
-                //create a new scope for this xml file
-                let scope = new XmlScope_1.XmlScope(xmlFile, this);
-                this.addScope(scope);
-                //register this compoent now that we have parsed it and know its component name
-                this.registerComponent(xmlFile, scope);
-                this.plugins.emit('afterFileParse', {
-                    program: this,
-                    file: xmlFile
-                });
+            if (param.dest) {
+                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.dest)}`;
             }
-            else {
-                //TODO do we actually need to implement this? Figure out how to handle img paths
-                // let genericFile = this.files[srcPath] = <any>{
-                //     srcPath: srcPath,
-                //     pkgPath: pkgPath,
-                //     wasProcessed: true
-                // } as File;
-                // file = <any>genericFile;
+            if (param.pkgPath) {
+                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.pkgPath)}`;
             }
-            return file;
-        });
+        }
+        //if there's no srcPath, use the destPath to build an absolute srcPath
+        if (!srcPath) {
+            srcPath = (0, util_1.standardizePath) `${rootDir}/${destPath}`;
+        }
+        //coerce srcPath to an absolute path
+        if (!path.isAbsolute(srcPath)) {
+            srcPath = util_1.util.standardizePath(srcPath);
+        }
+        //if destPath isn't set, compute it from the other paths
+        if (!destPath) {
+            destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
+        }
+        assert.ok(srcPath, 'fileEntry.src is required');
+        assert.ok(destPath, 'fileEntry.dest is required');
+        return {
+            srcPath: srcPath,
+            //remove leading slash
+            destPath: destPath.replace(/^[\/\\]+/, '')
+        };
+    }
+    /**
+     * Remove any leading `pkg:/` found in the path
+     */
+    removePkgPrefix(path) {
+        return path.replace(/^pkg:\//i, '');
+    }
+    /**
+     * Is this file a .brs file found somewhere within the `pkg:/source/` folder?
+     */
+    isSourceBrsFile(file) {
+        return !!/^(pkg:\/)?source[\/\\]/.exec(file.destPath);
+    }
+    /**
+     * Is this file a .brs file found somewhere within the `pkg:/source/` folder?
+     */
+    isComponentsXmlFile(file) {
+        return (0, reflection_1.isXmlFile)(file) && !!/^(pkg:\/)?components[\/\\]/.exec(file.destPath);
     }
     /**
      * Ensure source scope is created.
@@ -381,238 +595,373 @@ class Program {
             const sourceScope = new Scope_1.Scope('source', this, 'scope:source');
             sourceScope.attachDependencyGraph(this.dependencyGraph);
             this.addScope(sourceScope);
+            this.plugins.emit('afterScopeCreate', {
+                program: this,
+                scope: sourceScope
+            });
         }
     }
     /**
      * Remove a set of files from the program
-     * @param srcPaths
+     * @param srcPaths can be an array of srcPath or destPath strings
+     * @param normalizePath should this function repair and standardize the filePaths? Passing false should have a performance boost if you can guarantee your paths are already sanitized
      */
-    removeFiles(srcPaths) {
+    removeFiles(srcPaths, normalizePath = true) {
         for (let srcPath of srcPaths) {
-            this.removeFile(srcPath);
+            this.removeFile(srcPath, normalizePath);
         }
     }
     /**
      * Remove a file from the program
-     * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
+     * @param filePath can be a srcPath, a destPath, or a destPath with leading `pkg:/`
      * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
-
      */
-    removeFile(filePath, normalizePath = true) {
+    removeFile(filePath, normalizePath = true, keepSymbolInformation = false) {
+        var _a, _b, _c, _d;
         this.logger.debug('Program.removeFile()', filePath);
-        let file = this.getFile(filePath, normalizePath);
-        if (file) {
-            this.plugins.emit('beforeFileDispose', {
-                program: this,
-                file: file
-            });
+        const paths = this.getPaths(filePath, this.options.rootDir);
+        //there can be one or more File entries for a single srcPath, so get all of them and remove them all
+        const files = (_b = this.fileClusters.get((_a = paths.srcPath) === null || _a === void 0 ? void 0 : _a.toLowerCase())) !== null && _b !== void 0 ? _b : [this.getFile(filePath, normalizePath)];
+        for (const file of files) {
+            //if a file has already been removed, nothing more needs to be done here
+            if (!file || !this.hasFile(file.srcPath)) {
+                continue;
+            }
+            this.diagnostics.clearForFile(file.srcPath);
+            const event = { file: file, program: this };
+            this.plugins.emit('beforeFileRemove', event);
             //if there is a scope named the same as this file's path, remove it (i.e. xml scopes)
-            let scope = this.scopes[file.pkgPath];
+            let scope = this.scopes[file.destPath];
             if (scope) {
-                this.plugins.emit('beforeScopeDispose', {
+                const scopeDisposeEvent = {
                     program: this,
                     scope: scope
-                });
+                };
+                this.plugins.emit('beforeScopeDispose', scopeDisposeEvent);
+                this.plugins.emit('onScopeDispose', scopeDisposeEvent);
                 scope.dispose();
                 //notify dependencies of this scope that it has been removed
                 this.dependencyGraph.remove(scope.dependencyGraphKey);
-                delete this.scopes[file.pkgPath];
-                this.plugins.emit('afterScopeDispose', {
-                    program: this,
-                    scope: scope
-                });
+                delete this.scopes[file.destPath];
+                this.plugins.emit('afterScopeDispose', scopeDisposeEvent);
             }
             //remove the file from the program
             this.unassignFile(file);
             this.dependencyGraph.remove(file.dependencyGraphKey);
             //if this is a pkg:/source file, notify the `source` scope that it has changed
-            if (file.pkgPath.startsWith('pkg:/source/')) {
+            if (this.isSourceBrsFile(file)) {
                 this.dependencyGraph.removeDependency('scope:source', file.dependencyGraphKey);
             }
+            if ((0, reflection_1.isBrsFile)(file)) {
+                if (!keepSymbolInformation) {
+                    this.fileSymbolInformation.delete(file.pkgPath);
+                }
+                this.crossScopeValidation.clearResolutionsForFile(file);
+            }
             //if this is a component, remove it from our components map
-            if (reflection_1.isXmlFile(file)) {
+            if ((0, reflection_1.isXmlFile)(file)) {
                 this.unregisterComponent(file);
             }
-            this.plugins.emit('afterFileDispose', {
-                program: this,
-                file: file
-            });
-        }
-    }
-    /**
-     * Remove all files from the program that are in the specified folder path (recursive)
-     * @param folderSrcPath The absolute path to the folder on disk
-     * @param normalizePath should the provided path be normalized before use?
-     */
-    removeFilesInFolder(folderSrcPath, normalizePath = true) {
-        if (normalizePath) {
-            folderSrcPath = util_1.util.standardizePath(folderSrcPath);
-        }
-        const lowerFolderSrcPath = folderSrcPath.toLowerCase();
-        for (const key in this.files) {
-            const file = this.files[key];
-            const lowerSrcPath = file.srcPath.toLowerCase();
-            //if the file path starts with the parent path and the file path does not exactly match the folder path
-            if (lowerSrcPath.toLowerCase().startsWith(lowerFolderSrcPath) && lowerSrcPath !== lowerFolderSrcPath) {
-                this.removeFile(file.srcPath, false);
+            //dispose any disposable things on the file
+            for (const disposable of (_c = file === null || file === void 0 ? void 0 : file.disposables) !== null && _c !== void 0 ? _c : []) {
+                disposable();
             }
+            //dispose file
+            (_d = file === null || file === void 0 ? void 0 : file.dispose) === null || _d === void 0 ? void 0 : _d.call(file);
+            this.plugins.emit('afterFileRemove', event);
         }
     }
     /**
      * Traverse the entire project, and validate all scopes
-     * @param force - if true, then all scopes are force to validate, even if they aren't marked as dirty
      */
     validate() {
-        this.logger.time(Logger_1.LogLevel.log, ['Validating project'], () => {
-            var _a;
-            this.diagnostics = [];
-            this.plugins.emit('beforeProgramValidate', {
+        this.logger.time(logging_1.LogLevel.log, ['Validating project'], () => {
+            this.diagnostics.clearForTag(ProgramValidator_1.ProgramValidatorDiagnosticsTag);
+            const programValidateEvent = {
                 program: this
-            });
+            };
+            this.plugins.emit('beforeProgramValidate', programValidateEvent);
+            this.plugins.emit('onProgramValidate', programValidateEvent);
+            const metrics = {
+                filesChanged: 0,
+                filesValidated: 0,
+                fileValidationTime: '',
+                crossScopeValidationTime: '',
+                scopesValidated: 0,
+                totalLinkTime: '',
+                totalScopeValidationTime: '',
+                componentValidationTime: ''
+            };
+            const validationStopwatch = new Stopwatch_1.Stopwatch();
             //validate every file
-            for (const file of Object.values(this.files)) {
-                //find any files NOT loaded into a scope
-                if (!this.fileIsIncludedInAnyScope(file)) {
-                    this.logger.debug('Program.validate(): fileNotReferenced by any scope', () => chalk_1.default.green(file === null || file === void 0 ? void 0 : file.pkgPath));
-                    //the file is not loaded in any scope
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.fileNotReferencedByAnyOtherFile()), { file: file, range: util_1.util.createRange(0, 0, 0, Number.MAX_VALUE) }));
+            const brsFilesValidated = [];
+            const afterValidateFiles = [];
+            metrics.fileValidationTime = validationStopwatch.getDurationTextFor(() => {
+                //sort files by path so we get consistent results
+                const files = Object.values(this.files).sort((0, thenby_1.firstBy)(x => x.srcPath));
+                for (const file of files) {
+                    //for every unvalidated file, validate it
+                    if (!file.isValidated) {
+                        const validateFileEvent = {
+                            program: this,
+                            file: file
+                        };
+                        this.plugins.emit('beforeFileValidate', validateFileEvent);
+                        //emit an event to allow plugins to contribute to the file validation process
+                        this.plugins.emit('onFileValidate', validateFileEvent);
+                        file.isValidated = true;
+                        if ((0, reflection_1.isBrsFile)(file)) {
+                            brsFilesValidated.push(file);
+                        }
+                        afterValidateFiles.push(file);
+                    }
                 }
-                //for every unvalidated file, validate it
-                if (!file.isValidated) {
-                    this.plugins.emit('beforeFileValidate', {
-                        program: this,
-                        file: file
-                    });
-                    //call file.validate() IF the file has that function defined
-                    (_a = file.validate) === null || _a === void 0 ? void 0 : _a.call(file);
-                    file.isValidated = true;
-                    this.plugins.emit('afterFileValidate', {
+                // AfterFileValidate is after all files have been validated
+                for (const file of afterValidateFiles) {
+                    const validateFileEvent = {
                         program: this,
                         file: file
-                    });
+                    };
+                    this.plugins.emit('afterFileValidate', validateFileEvent);
                 }
+            }).durationText;
+            metrics.filesChanged = afterValidateFiles.length;
+            // Build component types for any component that changes
+            this.logger.time(logging_1.LogLevel.info, ['Build component types'], () => {
+                for (let { componentKey, componentName } of this.componentSymbolsToUpdate) {
+                    this.updateComponentSymbolInGlobalScope(componentKey, componentName);
+                }
+                this.componentSymbolsToUpdate.clear();
+            });
+            const changedSymbolsMapArr = brsFilesValidated === null || brsFilesValidated === void 0 ? void 0 : brsFilesValidated.map(f => {
+                if ((0, reflection_1.isBrsFile)(f)) {
+                    return f.providedSymbols.changes;
+                }
+                return null;
+            }).filter(x => x);
+            const changedSymbols = new Map();
+            for (const flag of [1 /* SymbolTypeFlag.runtime */, 2 /* SymbolTypeFlag.typetime */]) {
+                const changedSymbolsSetArr = changedSymbolsMapArr.map(symMap => symMap.get(flag));
+                changedSymbols.set(flag, new Set(...changedSymbolsSetArr));
             }
-            this.logger.time(Logger_1.LogLevel.info, ['Validate all scopes'], () => {
-                for (let scope of Object.values(this.scopes)) {
-                    //only validate unvalidated scopes
-                    if (!scope.isValidated) {
-                        this.plugins.emit('beforeScopeValidate', {
-                            program: this,
-                            scope: scope
-                        });
-                        scope.validate();
-                        scope.isValidated = true;
-                        this.plugins.emit('afterScopeValidate', {
-                            program: this,
-                            scope: scope
-                        });
+            const filesToBeValidatedInScopeContext = new Set(afterValidateFiles);
+            metrics.crossScopeValidationTime = validationStopwatch.getDurationTextFor(() => {
+                const scopesToCheck = this.getScopesForCrossScopeValidation();
+                this.crossScopeValidation.buildComponentsMap();
+                this.crossScopeValidation.addDiagnosticsForScopes(scopesToCheck);
+                const filesToRevalidate = this.crossScopeValidation.getFilesRequiringChangedSymbol(scopesToCheck, changedSymbols);
+                for (const file of filesToRevalidate) {
+                    filesToBeValidatedInScopeContext.add(file);
+                }
+            }).durationText;
+            metrics.filesValidated = filesToBeValidatedInScopeContext.size;
+            let linkTime = 0;
+            let validationTime = 0;
+            let scopesValidated = 0;
+            let changedFiles = new Set(afterValidateFiles);
+            this.logger.time(logging_1.LogLevel.info, ['Validate all scopes'], () => {
+                //sort the scope names so we get consistent results
+                const scopeNames = this.getSortedScopeNames();
+                for (const file of filesToBeValidatedInScopeContext) {
+                    if ((0, reflection_1.isBrsFile)(file)) {
+                        file.validationSegmenter.unValidateAllSegments();
                     }
                 }
+                for (let scopeName of scopeNames) {
+                    let scope = this.scopes[scopeName];
+                    const scopeValidated = scope.validate({
+                        filesToBeValidatedInScopeContext: filesToBeValidatedInScopeContext,
+                        changedSymbols: changedSymbols,
+                        changedFiles: changedFiles,
+                        initialValidation: this.isFirstValidation
+                    });
+                    if (scopeValidated) {
+                        scopesValidated++;
+                    }
+                    linkTime += scope.validationMetrics.linkTime;
+                    validationTime += scope.validationMetrics.validationTime;
+                }
             });
-            this.detectDuplicateComponentNames();
-            this.plugins.emit('afterProgramValidate', {
-                program: this
-            });
+            metrics.scopesValidated = scopesValidated;
+            validationStopwatch.totalMilliseconds = linkTime;
+            metrics.totalLinkTime = validationStopwatch.getDurationText();
+            validationStopwatch.totalMilliseconds = validationTime;
+            metrics.totalScopeValidationTime = validationStopwatch.getDurationText();
+            metrics.componentValidationTime = validationStopwatch.getDurationTextFor(() => {
+                this.detectDuplicateComponentNames();
+            }).durationText;
+            this.logValidationMetrics(metrics);
+            this.isFirstValidation = false;
+            this.plugins.emit('afterProgramValidate', programValidateEvent);
         });
     }
+    // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
+    logValidationMetrics(metrics) {
+        let logs = [];
+        for (const key in metrics) {
+            logs.push(`${key}=${chalk_1.default.yellow(metrics[key].toString())}`);
+        }
+        this.logger.info(`Validation Metrics: ${logs.join(', ')}`);
+    }
+    getScopesForCrossScopeValidation() {
+        const scopesForCrossScopeValidation = [];
+        for (let scopeName of this.getSortedScopeNames()) {
+            let scope = this.scopes[scopeName];
+            if (this.globalScope !== scope && !scope.isValidated) {
+                scopesForCrossScopeValidation.push(scope);
+            }
+        }
+        return scopesForCrossScopeValidation;
+    }
     /**
      * Flag all duplicate component names
      */
     detectDuplicateComponentNames() {
-        var _a;
-        const componentsByName = new Map();
-        for (const key in this.files) {
-            const file = this.files[key];
+        const componentsByName = Object.keys(this.files).reduce((map, filePath) => {
+            var _a;
+            const file = this.files[filePath];
             //if this is an XmlFile, and it has a valid `componentName` property
-            if (reflection_1.isXmlFile(file)) {
-                const componentNameLower = (_a = file.componentName) === null || _a === void 0 ? void 0 : _a.text.toLowerCase();
-                if (componentNameLower) {
-                    if (!componentsByName.has(componentNameLower)) {
-                        componentsByName.set(componentNameLower, [file]);
-                    }
-                    else {
-                        componentsByName.get(componentNameLower).push(file);
-                    }
+            if ((0, reflection_1.isXmlFile)(file) && ((_a = file.componentName) === null || _a === void 0 ? void 0 : _a.text)) {
+                let lowerName = file.componentName.text.toLowerCase();
+                if (!map[lowerName]) {
+                    map[lowerName] = [];
                 }
+                map[lowerName].push(file);
             }
-        }
-        for (const xmlFiles of componentsByName.values()) {
+            return map;
+        }, {});
+        for (let name in componentsByName) {
+            const xmlFiles = componentsByName[name];
             //add diagnostics for every duplicate component with this name
             if (xmlFiles.length > 1) {
                 for (let xmlFile of xmlFiles) {
                     const { componentName } = xmlFile;
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateComponentName(componentName.text)), { range: xmlFile.componentName.range, file: xmlFile, relatedInformation: xmlFiles.filter(x => x !== xmlFile).map(x => {
+                    this.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateComponentName(componentName.text)), { range: xmlFile.componentName.range, file: xmlFile, relatedInformation: xmlFiles.filter(x => x !== xmlFile).map(x => {
+                            var _a;
                             return {
-                                location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(xmlFile.srcPath).toString(), x.componentName.range),
+                                location: util_1.util.createLocation(vscode_uri_1.URI.file((_a = xmlFile.srcPath) !== null && _a !== void 0 ? _a : xmlFile.srcPath).toString(), x.componentName.range),
                                 message: 'Also defined here'
                             };
-                        }) }));
+                        }) }), { tags: [ProgramValidator_1.ProgramValidatorDiagnosticsTag] });
                 }
             }
         }
     }
     /**
-     * Determine at least one scope has the file
+     * Get the files for a list of filePaths
+     * @param filePaths can be an array of srcPath or a destPath strings
+     * @param normalizePath should this function repair and standardize the paths? Passing false should have a performance boost if you can guarantee your paths are already sanitized
      */
-    fileIsIncludedInAnyScope(file) {
-        for (let scope of Object.values(this.scopes)) {
-            if (scope.hasFile(file)) {
-                return true;
-            }
-        }
-        return false;
+    getFiles(filePaths, normalizePath = true) {
+        return filePaths
+            .map(filePath => this.getFile(filePath, normalizePath))
+            .filter(file => file !== undefined);
     }
     /**
      * Get the file at the given path
-     * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
+     * @param filePath can be a srcPath or a destPath
      * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
      */
     getFile(filePath, normalizePath = true) {
         if (typeof filePath !== 'string') {
             return undefined;
+            //is the path absolute (or the `virtual:` prefix)
         }
-        else if (path.isAbsolute(filePath)) {
+        else if (/^(?:(?:virtual:[\/\\])|(?:\w:)|(?:[\/\\]))/gmi.exec(filePath)) {
             return this.files[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
         }
         else {
-            return this.pkgMap[(normalizePath ? util_1.util.sanitizePkgPath(filePath) : filePath).toLowerCase()];
+            return this.destMap.get((normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase());
         }
     }
+    /**
+     * Gets a sorted list of all scopeNames, always beginning with "global", "source", then any others in alphabetical order
+     */
+    getSortedScopeNames() {
+        return Object.keys(this.scopes).sort((a, b) => {
+            if (a === 'global') {
+                return -1;
+            }
+            else if (b === 'global') {
+                return 1;
+            }
+            if (a === 'source') {
+                return -1;
+            }
+            else if (b === 'source') {
+                return 1;
+            }
+            if (a < b) {
+                return -1;
+            }
+            else if (b < a) {
+                return 1;
+            }
+            return 0;
+        });
+    }
     /**
      * Get a list of all scopes the file is loaded into
-     * @param file
+     * @param file the file
      */
     getScopesForFile(file) {
+        const resolvedFile = typeof file === 'string' ? this.getFile(file) : file;
         let result = [];
-        for (let key in this.scopes) {
+        if (resolvedFile) {
+            const scopeKeys = this.getSortedScopeNames();
+            for (let key of scopeKeys) {
+                let scope = this.scopes[key];
+                if (scope.hasFile(resolvedFile)) {
+                    result.push(scope);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get the first found scope for a file.
+     */
+    getFirstScopeForFile(file) {
+        const scopeKeys = this.getSortedScopeNames();
+        for (let key of scopeKeys) {
             let scope = this.scopes[key];
             if (scope.hasFile(file)) {
-                result.push(scope);
+                return scope;
             }
         }
-        return result;
     }
     getStatementsByName(name, originFile, namespaceName) {
-        var _a, _b;
         let results = new Map();
         const filesSearched = new Set();
         let lowerNamespaceName = namespaceName === null || namespaceName === void 0 ? void 0 : namespaceName.toLowerCase();
         let lowerName = name === null || name === void 0 ? void 0 : name.toLowerCase();
+        function addToResults(statement, file) {
+            var _a, _b;
+            let parentNamespaceName = (_b = (_a = statement.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(originFile.parseMode)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+            if (statement.tokens.name.text.toLowerCase() === lowerName && (!lowerNamespaceName || parentNamespaceName === lowerNamespaceName)) {
+                if (!results.has(statement)) {
+                    results.set(statement, { item: statement, file: file });
+                }
+            }
+        }
         //look through all files in scope for matches
         for (const scope of this.getScopesForFile(originFile)) {
             for (const file of scope.getAllFiles()) {
-                if (reflection_1.isXmlFile(file) || filesSearched.has(file)) {
+                //skip non-brs files, or files we've already processed
+                if (!(0, reflection_1.isBrsFile)(file) || filesSearched.has(file)) {
                     continue;
                 }
                 filesSearched.add(file);
-                for (const statement of [...file.parser.references.functionStatements, ...file.parser.references.classStatements.flatMap((cs) => cs.methods)]) {
-                    let parentNamespaceName = (_b = (_a = statement.namespaceName) === null || _a === void 0 ? void 0 : _a.getName(originFile.parseMode)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
-                    if (statement.name.text.toLowerCase() === lowerName && (!parentNamespaceName || parentNamespaceName === lowerNamespaceName)) {
-                        if (!results.has(statement)) {
-                            results.set(statement, { item: statement, file: file });
-                        }
+                file.ast.walk((0, visitors_1.createVisitor)({
+                    FunctionStatement: (statement) => {
+                        addToResults(statement, file);
+                    },
+                    MethodStatement: (statement) => {
+                        addToResults(statement, file);
                     }
-                }
+                }), {
+                    walkMode: visitors_1.WalkMode.visitStatements
+                });
             }
         }
         return [...results.values()];
@@ -624,8 +973,8 @@ class Program {
         //get all function names for the xml file and parents
         let funcNames = new Set();
         let currentScope = scope;
-        while (reflection_1.isXmlScope(currentScope)) {
-            for (let name of (_b = (_a = currentScope.xmlFile.ast.component.api) === null || _a === void 0 ? void 0 : _a.functions.map((f) => f.name)) !== null && _b !== void 0 ? _b : []) {
+        while ((0, reflection_1.isXmlScope)(currentScope)) {
+            for (let name of (_b = (_a = currentScope.xmlFile.ast.componentElement.interfaceElement) === null || _a === void 0 ? void 0 : _a.functions.map((f) => f.name)) !== null && _b !== void 0 ? _b : []) {
                 if (!filterName || name === filterName) {
                     funcNames.add(name);
                 }
@@ -634,109 +983,128 @@ class Program {
         }
         //look through all files in scope for matches
         for (const file of scope.getOwnFiles()) {
-            if (reflection_1.isXmlFile(file) || filesSearched.has(file)) {
+            //skip non-brs files, or files we've already processed
+            if (!(0, reflection_1.isBrsFile)(file) || filesSearched.has(file)) {
                 continue;
             }
             filesSearched.add(file);
-            for (const statement of file.parser.references.functionStatements) {
-                if (funcNames.has(statement.name.text)) {
-                    if (!results.has(statement)) {
-                        results.set(statement, { item: statement, file: file });
+            file.ast.walk((0, visitors_1.createVisitor)({
+                FunctionStatement: (statement) => {
+                    if (funcNames.has(statement.tokens.name.text)) {
+                        if (!results.has(statement)) {
+                            results.set(statement, { item: statement, file: file });
+                        }
                     }
                 }
-            }
+            }), {
+                walkMode: visitors_1.WalkMode.visitStatements
+            });
         }
         return [...results.values()];
     }
     /**
      * Find all available completion items at the given position
-     * @param srcPath The absolute path to the source file on disk
-     * @param lineIndex
-     * @param columnIndex
+     * @param filePath can be a srcPath or a destPath
+     * @param position the position (line & column) where completions should be found
      */
-    getCompletions(srcPath, position) {
-        let file = this.getFile(srcPath);
+    getCompletions(filePath, position) {
+        let file = this.getFile(filePath);
         if (!file) {
             return [];
         }
-        let result = [];
-        if (reflection_1.isBrsFile(file) && file.parser.isPositionNextToTokenKind(position, lexer_1.TokenKind.Callfunc)) {
-            // is next to a @. callfunc invocation - must be an interface method
-            for (const scope of this.getScopes().filter((s) => reflection_1.isXmlScope(s))) {
-                let fileLinks = this.getStatementsForXmlFile(scope);
-                for (let fileLink of fileLinks) {
-                    result.push(scope.createCompletionFromFunctionStatement(fileLink.item));
-                }
-            }
-            //no other result is possible in this case
-            return result;
-        }
         //find the scopes for this file
         let scopes = this.getScopesForFile(file);
         //if there are no scopes, include the global scope so we at least get the built-in functions
         scopes = scopes.length > 0 ? scopes : [this.globalScope];
-        //get the completions from all scopes for this file
-        let allCompletions = util_1.util.flatMap(scopes.map(ctx => file.getCompletions(position, ctx)), c => c);
-        //only keep completions common to every scope for this file
-        let keyCounts = {};
-        for (let completion of allCompletions) {
-            let key = `${completion.label}-${completion.kind}`;
-            keyCounts[key] = keyCounts[key] ? keyCounts[key] + 1 : 1;
-            if (keyCounts[key] === scopes.length) {
-                result.push(completion);
-            }
-        }
-        return result;
+        const event = {
+            program: this,
+            file: file,
+            scopes: scopes,
+            position: position,
+            completions: []
+        };
+        this.plugins.emit('beforeProvideCompletions', event);
+        this.plugins.emit('provideCompletions', event);
+        this.plugins.emit('afterProvideCompletions', event);
+        return event.completions;
     }
     /**
      * Goes through each file and builds a list of workspace symbols for the program. Used by LanguageServer's onWorkspaceSymbol functionality
      */
     getWorkspaceSymbols() {
-        const result = [];
-        for (const key in this.files) {
-            const file = this.files[key];
-            if (reflection_1.isBrsFile(file)) {
-                result.push(...file.getWorkspaceSymbols());
-            }
-        }
-        return result;
+        const event = {
+            program: this,
+            workspaceSymbols: []
+        };
+        this.plugins.emit('beforeProvideWorkspaceSymbols', event);
+        this.plugins.emit('provideWorkspaceSymbols', event);
+        this.plugins.emit('afterProvideWorkspaceSymbols', event);
+        return event.workspaceSymbols;
     }
     /**
      * Given a position in a file, if the position is sitting on some type of identifier,
      * go to the definition of that identifier (where this thing was first defined)
-     * @param srcPath The absolute path to the source file on disk
      */
     getDefinition(srcPath, position) {
         let file = this.getFile(srcPath);
         if (!file) {
             return [];
         }
-        if (reflection_1.isBrsFile(file)) {
-            return file.getDefinition(position);
-        }
-        else {
-            let results = [];
-            const scopes = this.getScopesForFile(file);
-            for (const scope of scopes) {
-                results = results.concat(...scope.getDefinition(file, position));
-            }
-            return results;
-        }
+        const event = {
+            program: this,
+            file: file,
+            position: position,
+            definitions: []
+        };
+        this.plugins.emit('beforeProvideDefinition', event);
+        this.plugins.emit('provideDefinition', event);
+        this.plugins.emit('afterProvideDefinition', event);
+        return event.definitions;
     }
     /**
-     * @param srcPath The absolute path to the source file on disk
+     * Get hover information for a file and position
      */
     getHover(srcPath, position) {
-        //find the file
         let file = this.getFile(srcPath);
-        if (!file) {
-            return null;
+        let result;
+        if (file) {
+            const event = {
+                program: this,
+                file: file,
+                position: position,
+                scopes: this.getScopesForFile(file),
+                hovers: []
+            };
+            this.plugins.emit('beforeProvideHover', event);
+            this.plugins.emit('provideHover', event);
+            this.plugins.emit('afterProvideHover', event);
+            result = event.hovers;
+        }
+        return result !== null && result !== void 0 ? result : [];
+    }
+    /**
+     * Get full list of document symbols for a file
+     * @param srcPath path to the file
+     */
+    getDocumentSymbols(srcPath) {
+        let file = this.getFile(srcPath);
+        if (file) {
+            const event = {
+                program: this,
+                file: file,
+                documentSymbols: []
+            };
+            this.plugins.emit('beforeProvideDocumentSymbols', event);
+            this.plugins.emit('provideDocumentSymbols', event);
+            this.plugins.emit('afterProvideDocumentSymbols', event);
+            return event.documentSymbols;
+        }
+        else {
+            return undefined;
         }
-        return Promise.resolve(file.getHover(position));
     }
     /**
      * Compute code actions for the given file and range
-     * @param srcPath The absolute path to the source file on disk
      */
     getCodeActions(srcPath, range) {
         const codeActions = [];
@@ -748,7 +1116,7 @@ class Program {
                 //only keep diagnostics related to this file
                 .filter(x => x.file === file)
                 //only keep diagnostics that touch this range
-                .filter(x => util_1.util.rangesIntersect(x.range, range));
+                .filter(x => util_1.util.rangesIntersectOrTouch(x.range, range));
             const scopes = this.getScopesForFile(file);
             this.plugins.emit('onGetCodeActions', {
                 program: this,
@@ -761,362 +1129,262 @@ class Program {
         }
         return codeActions;
     }
+    /**
+     * Get semantic tokens for the specified file
+     */
+    getSemanticTokens(srcPath) {
+        const file = this.getFile(srcPath);
+        if (file) {
+            const result = [];
+            this.plugins.emit('onGetSemanticTokens', {
+                program: this,
+                file: file,
+                scopes: this.getScopesForFile(file),
+                semanticTokens: result
+            });
+            return result;
+        }
+    }
     getSignatureHelp(filepath, position) {
-        var _a;
         let file = this.getFile(filepath);
-        if (!file || !reflection_1.isBrsFile(file)) {
+        if (!file || !(0, reflection_1.isBrsFile)(file)) {
             return [];
         }
-        const results = new Map();
-        let functionExpression = file.getFunctionExpressionAtPosition(position);
-        let identifierInfo = this.getPartialStatementInfo(file, position);
-        if (identifierInfo.statementType === '') {
-            // just general function calls
-            let statements = file.program.getStatementsByName(identifierInfo.name, file);
-            for (let statement of statements) {
-                //TODO better handling of collisions - if it's a namespace, then don't show any other overrides
-                //if we're on m - then limit scope to the current class, if present
-                let sigHelp = statement.file.getSignatureHelpForStatement(statement.item);
-                if (sigHelp && !results.has[sigHelp.key]) {
-                    sigHelp.index = identifierInfo.commaCount;
-                    results.set(sigHelp.key, sigHelp);
-                }
-            }
-        }
-        else if (identifierInfo.statementType === '.') {
-            //if m class reference.. then
-            //only get statements from the class I am in..
-            if (functionExpression) {
-                let myClass = file.getClassFromMReference(position, file.parser.getTokenAt(position), functionExpression);
-                if (myClass) {
-                    for (let scope of this.getScopesForFile(myClass.file)) {
-                        let classes = scope.getClassHierarchy(myClass.item.getName(parser_1.ParseMode.BrighterScript).toLowerCase());
-                        //and anything from any class in scope to a non m class
-                        for (let statement of [...classes].filter((i) => reflection_1.isClassMethodStatement(i.item))) {
-                            let sigHelp = statement.file.getSignatureHelpForStatement(statement.item);
-                            if (sigHelp && !results.has[sigHelp.key]) {
-                                results.set(sigHelp.key, sigHelp);
-                                return;
-                            }
-                        }
-                    }
-                }
-            }
-            if (identifierInfo.dotPart) {
-                //potential namespaces
-                let statements = file.program.getStatementsByName(identifierInfo.name, file, identifierInfo.dotPart);
-                if (statements.length === 0) {
-                    //was not a namespaced function, it could be any method on any class now
-                    statements = file.program.getStatementsByName(identifierInfo.name, file);
-                }
-                for (let statement of statements) {
-                    //TODO better handling of collisions - if it's a namespace, then don't show any other overrides
-                    //if we're on m - then limit scope to the current class, if present
-                    let sigHelp = statement.file.getSignatureHelpForStatement(statement.item);
-                    if (sigHelp && !results.has[sigHelp.key]) {
-                        sigHelp.index = identifierInfo.commaCount;
-                        results.set(sigHelp.key, sigHelp);
-                    }
-                }
-            }
-        }
-        else if (identifierInfo.statementType === '@.') {
-            for (const scope of this.getScopes().filter((s) => reflection_1.isXmlScope(s))) {
-                let fileLinks = this.getStatementsForXmlFile(scope, identifierInfo.name);
-                for (let fileLink of fileLinks) {
-                    let sigHelp = fileLink.file.getSignatureHelpForStatement(fileLink.item);
-                    if (sigHelp && !results.has[sigHelp.key]) {
-                        sigHelp.index = identifierInfo.commaCount;
-                        results.set(sigHelp.key, sigHelp);
-                    }
-                }
-            }
-        }
-        else if (identifierInfo.statementType === 'new') {
-            let classItem = file.getClassFileLink(identifierInfo.dotPart ? `${identifierInfo.dotPart}.${identifierInfo.name}` : identifierInfo.name);
-            let sigHelp = (_a = classItem === null || classItem === void 0 ? void 0 : classItem.file) === null || _a === void 0 ? void 0 : _a.getClassSignatureHelp(classItem === null || classItem === void 0 ? void 0 : classItem.item);
-            if (sigHelp && !results.has(sigHelp.key)) {
-                sigHelp.index = identifierInfo.commaCount;
-                results.set(sigHelp.key, sigHelp);
-            }
-        }
-        return [...results.values()];
+        let callExpressionInfo = new CallExpressionInfo_1.CallExpressionInfo(file, position);
+        let signatureHelpUtil = new SignatureHelpUtil_1.SignatureHelpUtil();
+        return signatureHelpUtil.getSignatureHelpItems(callExpressionInfo);
     }
-    getPartialStatementInfo(file, position) {
-        let lines = util_1.util.splitIntoLines(file.fileContents);
-        let line = lines[position.line];
-        let index = position.character;
-        let itemCounts = this.getPartialItemCounts(line, index);
-        if (!itemCounts.isArgStartFound && line.charAt(index) === ')') {
-            //try previous char, in case we were on a close bracket..
-            index--;
-            itemCounts = this.getPartialItemCounts(line, index);
-        }
-        let argStartIndex = itemCounts.argStartIndex;
-        index = itemCounts.argStartIndex - 1;
-        let statementType = '';
-        let name;
-        let dotPart;
-        if (!itemCounts.isArgStartFound) {
-            //try to get sig help based on the name
-            index = position.character;
-            let currentToken = file.parser.getTokenAt(position);
-            if (currentToken && currentToken.kind !== lexer_1.TokenKind.Comment) {
-                name = file.getPartialVariableName(currentToken, [lexer_1.TokenKind.New]);
-                if (!name) {
-                    //try the previous token, incase we're on a bracket
-                    currentToken = file.parser.getPreviousToken(currentToken);
-                    name = file.getPartialVariableName(currentToken, [lexer_1.TokenKind.New]);
-                }
-                if (name === null || name === void 0 ? void 0 : name.indexOf('.')) {
-                    let parts = name.split('.');
-                    name = parts[parts.length - 1];
-                }
-                index = currentToken.range.start.character;
-                argStartIndex = index;
-            }
-            else {
-                // invalid location
-                index = 0;
-                itemCounts.comma = 0;
-            }
-        }
-        //this loop is quirky. walk to -1 (which will result in the last char being '' thus satisfying the situation where there is no leading whitespace).
-        while (index >= -1) {
-            if (!(/[a-z0-9_\.\@]/i).test(line.charAt(index))) {
-                if (!name) {
-                    name = line.substring(index + 1, argStartIndex);
-                }
-                else {
-                    dotPart = line.substring(index + 1, argStartIndex);
-                    if (dotPart.endsWith('.')) {
-                        dotPart = dotPart.substr(0, dotPart.length - 1);
+    getReferences(srcPath, position) {
+        //find the file
+        let file = this.getFile(srcPath);
+        const event = {
+            program: this,
+            file: file,
+            position: position,
+            references: []
+        };
+        this.plugins.emit('beforeProvideReferences', event);
+        this.plugins.emit('provideReferences', event);
+        this.plugins.emit('afterProvideReferences', event);
+        return event.references;
+    }
+    /**
+     * Transpile a single file and get the result as a string.
+     * This does not write anything to the file system.
+     *
+     * This should only be called by `LanguageServer`.
+     * Internal usage should call `_getTranspiledFileContents` instead.
+     * @param filePath can be a srcPath or a destPath
+     */
+    async getTranspiledFileContents(filePath) {
+        const file = this.getFile(filePath);
+        return this.getTranspiledFileContentsPipeline.run(async () => {
+            const result = {
+                destPath: file.destPath,
+                pkgPath: file.pkgPath,
+                srcPath: file.srcPath
+            };
+            const expectedPkgPath = file.pkgPath.toLowerCase();
+            const expectedMapPath = `${expectedPkgPath}.map`;
+            const expectedTypedefPkgPath = expectedPkgPath.replace(/\.brs$/i, '.d.bs');
+            //add a temporary plugin to tap into the file writing process
+            const plugin = this.plugins.addFirst({
+                name: 'getTranspiledFileContents',
+                beforeWriteFile: (event) => {
+                    const pkgPath = event.file.pkgPath.toLowerCase();
+                    switch (pkgPath) {
+                        //this is the actual transpiled file
+                        case expectedPkgPath:
+                            result.code = event.file.data.toString();
+                            break;
+                        //this is the sourcemap
+                        case expectedMapPath:
+                            result.map = event.file.data.toString();
+                            break;
+                        //this is the typedef
+                        case expectedTypedefPkgPath:
+                            result.typedef = event.file.data.toString();
+                            break;
+                        default:
+                        //no idea what this file is. just ignore it
                     }
+                    //mark every file as processed so it they don't get written to the output directory
+                    event.processedFiles.add(event.file);
                 }
-                break;
-            }
-            if (line.substr(index - 2, 2) === '@.') {
-                statementType = '@.';
-                name = name || line.substring(index, argStartIndex);
-                break;
+            });
+            try {
+                //now that the plugin has been registered, run the build with just this file
+                await this.build({
+                    files: [file]
+                });
             }
-            else if (line.charAt(index - 1) === '.' && statementType === '') {
-                statementType = '.';
-                name = name || line.substring(index, argStartIndex);
-                argStartIndex = index;
+            finally {
+                this.plugins.remove(plugin);
             }
-            index--;
-        }
-        if (line.substring(0, index).trim().endsWith('new')) {
-            statementType = 'new';
+            return result;
+        });
+    }
+    /**
+     * Get the absolute output path for a file
+     */
+    getOutputPath(file, stagingDir = this.getStagingDir()) {
+        return (0, util_1.standardizePath) `${stagingDir}/${file.pkgPath}`;
+    }
+    getStagingDir(stagingDir) {
+        var _a, _b;
+        let result = (_a = stagingDir !== null && stagingDir !== void 0 ? stagingDir : this.options.stagingDir) !== null && _a !== void 0 ? _a : this.options.stagingDir;
+        if (!result) {
+            result = roku_deploy_1.rokuDeploy.getOptions(this.options).stagingDir;
         }
-        return {
-            commaCount: itemCounts.comma,
-            statementType: statementType,
-            name: name,
-            dotPart: dotPart
-        };
+        result = (0, util_1.standardizePath) `${path.resolve((_b = this.options.cwd) !== null && _b !== void 0 ? _b : process.cwd(), result !== null && result !== void 0 ? result : '/')}`;
+        return result;
     }
-    getPartialItemCounts(line, index) {
-        let isArgStartFound = false;
-        let itemCounts = {
-            normal: 0,
-            square: 0,
-            curly: 0,
-            comma: 0,
-            endIndex: 0,
-            argStartIndex: index,
-            isArgStartFound: false
+    /**
+     * Prepare the program for building
+     * @param files the list of files that should be prepared
+     */
+    async prepare(files) {
+        const programEvent = {
+            program: this,
+            editor: this.editor,
+            files: files
         };
-        while (index >= 0) {
-            const currentChar = line.charAt(index);
-            if (currentChar === '\'') { //found comment, invalid index
-                itemCounts.isArgStartFound = false;
-                break;
+        //assign an editor to every file
+        for (const file of files) {
+            //if the file doesn't have an editor yet, assign one now
+            if (!file.editor) {
+                file.editor = new Editor_1.Editor();
             }
-            if (isArgStartFound) {
-                if (currentChar !== ' ') {
-                    break;
-                }
+        }
+        files.sort((a, b) => {
+            if (a.pkgPath < b.pkgPath) {
+                return -1;
+            }
+            else if (a.pkgPath > b.pkgPath) {
+                return 1;
             }
             else {
-                if (currentChar === ')') {
-                    itemCounts.normal++;
-                }
-                if (currentChar === ']') {
-                    itemCounts.square++;
-                }
-                if (currentChar === '}') {
-                    itemCounts.curly++;
-                }
-                if (currentChar === ',' && itemCounts.normal <= 0 && itemCounts.curly <= 0 && itemCounts.square <= 0) {
-                    itemCounts.comma++;
-                }
-                if (currentChar === '(') {
-                    if (itemCounts.normal === 0) {
-                        itemCounts.isArgStartFound = true;
-                        itemCounts.argStartIndex = index;
-                    }
-                    else {
-                        itemCounts.normal--;
-                    }
-                }
-                if (currentChar === '[') {
-                    itemCounts.square--;
-                }
-                if (currentChar === '{') {
-                    itemCounts.curly--;
-                }
+                return 1;
             }
-            index--;
+        });
+        await this.plugins.emitAsync('beforePrepareProgram', programEvent);
+        await this.plugins.emitAsync('prepareProgram', programEvent);
+        const stagingDir = this.getStagingDir();
+        const entries = [];
+        for (const file of files) {
+            //if the file doesn't have an editor yet, assign one now
+            if (!file.editor) {
+                file.editor = new Editor_1.Editor();
+            }
+            const event = {
+                program: this,
+                file: file,
+                editor: file.editor,
+                outputPath: this.getOutputPath(file, stagingDir)
+            };
+            await this.plugins.emitAsync('beforePrepareFile', event);
+            await this.plugins.emitAsync('prepareFile', event);
+            await this.plugins.emitAsync('afterPrepareFile', event);
+            //TODO remove this in v1
+            entries.push(event);
         }
-        return itemCounts;
+        await this.plugins.emitAsync('afterPrepareProgram', programEvent);
+        return files;
     }
     /**
-     * @param srcPath The absolute path to the source file on disk
+     * Generate the contents of every file
      */
-    getReferences(srcPath, position) {
-        //find the file
-        let file = this.getFile(srcPath);
-        if (!file) {
-            return null;
+    async serialize(files) {
+        const allFiles = new Map();
+        //exclude prunable files if that option is enabled
+        if (this.options.pruneEmptyCodeFiles === true) {
+            files = files.filter(x => x.canBePruned !== true);
         }
-        return file.getReferences(position);
-    }
-    /**
-     * Get a list of all script imports, relative to the specified pkgPath
-     * @param sourcePkgPath - the pkgPath of the source that wants to resolve script imports.
-     */
-    getScriptImportCompletions(sourcePkgPath, scriptImport) {
-        let lowerSourcePkgPath = sourcePkgPath.toLowerCase();
-        let result = [];
-        /**
-         * hashtable to prevent duplicate results
-         */
-        let resultPkgPaths = {};
-        //restrict to only .brs files
-        for (const key in this.files) {
-            const file = this.files[key];
-            if (
-            //is a BrightScript or BrighterScript file
-            (file.extension === '.bs' || file.extension === '.brs') &&
-                //this file is not the current file
-                lowerSourcePkgPath !== file.pkgPath.toLowerCase()) {
-                //add the relative path
-                let relativePath = util_1.util.getRelativePath(sourcePkgPath, file.pkgPath).replace(/\\/g, '/');
-                const lowerPkgPath = file.pkgPath.toLowerCase();
-                if (!resultPkgPaths[lowerPkgPath]) {
-                    resultPkgPaths[lowerPkgPath] = true;
-                    result.push({
-                        label: relativePath,
-                        detail: file.srcPath,
-                        kind: vscode_languageserver_1.CompletionItemKind.File,
-                        textEdit: {
-                            newText: relativePath,
-                            range: scriptImport.filePathRange
-                        }
-                    });
-                    //add the absolute path
-                    result.push({
-                        label: file.pkgPath,
-                        detail: file.srcPath,
-                        kind: vscode_languageserver_1.CompletionItemKind.File,
-                        textEdit: {
-                            newText: file.pkgPath,
-                            range: scriptImport.filePathRange
-                        }
-                    });
-                }
-            }
+        const serializeProgramEvent = await this.plugins.emitAsync('beforeSerializeProgram', {
+            program: this,
+            files: files,
+            result: allFiles
+        });
+        await this.plugins.emitAsync('onSerializeProgram', {
+            program: this,
+            files: files,
+            result: allFiles
+        });
+        //sort the entries to make transpiling more deterministic
+        files = serializeProgramEvent.files.sort((a, b) => {
+            return a.srcPath < b.srcPath ? -1 : 1;
+        });
+        // serialize each file
+        for (const file of files) {
+            const event = {
+                program: this,
+                file: file,
+                result: allFiles
+            };
+            await this.plugins.emitAsync('beforeSerializeFile', event);
+            await this.plugins.emitAsync('serializeFile', event);
+            await this.plugins.emitAsync('afterSerializeFile', event);
         }
-        return result;
+        this.plugins.emit('afterSerializeProgram', {
+            program: this,
+            files: files,
+            result: allFiles
+        });
+        return allFiles;
     }
     /**
-     * Transpile a single file and get the result as a string.
-     * This does not write anything to the file system.
-     * @param srcPath The absolute path to the source file on disk
+     * Write the entire project to disk
      */
-    getTranspiledFileContents(srcPath) {
-        let file = this.getFile(srcPath);
-        let result = file.transpile();
-        return Object.assign(Object.assign({}, result), { srcPath: file.srcPath, pkgPath: file.pkgPath });
-    }
-    async transpile(fileEntries, stagingFolderPath) {
-        // map fileEntries using their path as key to avoid excessive "find()" operations
-        const mappedFileEntries = fileEntries.reduce((collection, entry) => {
-            collection[util_1.standardizePath `${entry.src}`] = entry;
-            return collection;
-        }, {});
-        const entries = [];
-        for (const key in this.files) {
-            const file = this.files[key];
-            let filePathObj = mappedFileEntries[util_1.standardizePath `${file.srcPath}`];
-            if (!filePathObj) {
-                //this file has been added in-memory, from a plugin, for example
-                filePathObj = {
-                    //add an interpolated src path (since it doesn't actually exist in memory)
-                    src: `bsc-in-memory:/${util_1.util.removeProtocol(file.pkgPath)}`,
-                    dest: file.pkgPath
-                };
-            }
-            //prep the output path
-            let outputPath = filePathObj.dest
-                //replace any leading protocol
-                .replace(/^[-a-z_]+:\//, '')
-                //change any .bs file extension to .brs
-                .replace(/\.bs$/gi, '.brs');
-            //prepend the staging folder path
-            outputPath = util_1.standardizePath `${stagingFolderPath}/${outputPath}`;
-            entries.push({
-                file: file,
-                outputPath: outputPath
-            });
-        }
-        this.plugins.emit('beforeProgramTranspile', {
+    async write(stagingDir, files) {
+        const programEvent = await this.plugins.emitAsync('beforeWriteProgram', {
             program: this,
-            entries: entries
+            files: files,
+            stagingDir: stagingDir
         });
-        const promises = entries.map(async (entry) => {
-            //skip transpiling typedef files
-            if (reflection_1.isBrsFile(entry.file) && entry.file.isTypedef) {
-                return;
-            }
-            this.plugins.emit('beforeFileTranspile', {
+        //empty the staging directory
+        await fsExtra.emptyDir(stagingDir);
+        const serializedFiles = [...files]
+            .map(([, serializedFiles]) => serializedFiles)
+            .flat();
+        //write all the files to disk (asynchronously)
+        await Promise.all(serializedFiles.map(async (file) => {
+            const event = await this.plugins.emitAsync('beforeWriteFile', {
                 program: this,
-                file: entry.file,
-                outputPath: entry.outputPath
+                file: file,
+                outputPath: this.getOutputPath(file, stagingDir),
+                processedFiles: new Set()
             });
-            const { file, outputPath } = entry;
-            const result = file.transpile();
-            //make sure the full dir path exists
-            await fsExtra.ensureDir(path.dirname(outputPath));
-            if (await fsExtra.pathExists(outputPath)) {
-                throw new Error(`Error while transpiling "${file.srcPath}". A file already exists at "${outputPath}" and will not be overwritten.`);
-            }
-            const writeMapPromise = result.map ? fsExtra.writeFile(`${outputPath}.map`, result.map.toString()) : null;
-            await Promise.all([
-                fsExtra.writeFile(outputPath, result.code),
-                writeMapPromise
-            ]);
-            if (reflection_1.isBrsFile(file) && this.options.emitDefinitions) {
-                const typedef = file.getTypedef();
-                const typedefPath = outputPath.replace(/\.brs$/i, '.d.bs');
-                await fsExtra.writeFile(typedefPath, typedef);
-            }
-            this.plugins.emit('afterFileTranspile', {
+            await this.plugins.emitAsync('writeFile', event);
+            await this.plugins.emitAsync('afterWriteFile', event);
+        }));
+        await this.plugins.emitAsync('afterWriteProgram', programEvent);
+    }
+    /**
+     * Build the project. This transpiles/transforms/copies all files and moves them to the staging directory
+     * @param options the list of options used to build the program
+     */
+    async build(options) {
+        //run a single build at a time
+        await this.buildPipeline.run(async () => {
+            var _a;
+            const stagingDir = this.getStagingDir(options === null || options === void 0 ? void 0 : options.stagingDir);
+            const event = await this.plugins.emitAsync('beforeBuildProgram', {
                 program: this,
-                file: entry.file,
-                outputPath: entry.outputPath
+                editor: this.editor,
+                files: (_a = options === null || options === void 0 ? void 0 : options.files) !== null && _a !== void 0 ? _a : Object.values(this.files)
             });
-        });
-        //if there's no bslib file already loaded into the program, copy it to the staging directory
-        if (!this.getFile(bslibAliasedRokuModulesPkgPath) && !this.getFile(`pkg:/source/bslib.brs`)) {
-            promises.push(util_1.util.copyBslibToStaging(stagingFolderPath));
-        }
-        await Promise.all(promises);
-        this.plugins.emit('afterProgramTranspile', {
-            program: this,
-            entries: entries
+            //prepare the program (and files) for building
+            event.files = await this.prepare(event.files);
+            //stage the entire program
+            const serializedFilesByFile = await this.serialize(event.files);
+            await this.write(stagingDir, serializedFilesByFile);
+            await this.plugins.emitAsync('afterBuildProgram', event);
+            //undo all edits for the program
+            this.editor.undoAll();
+            //undo all edits for each file
+            for (const file of event.files) {
+                file.editor.undoAll();
+            }
         });
     }
     /**
@@ -1127,10 +1395,11 @@ class Program {
         const lowerFunctionName = functionName.toLowerCase();
         //find every file with this function defined
         for (const file of Object.values(this.files)) {
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 //TODO handle namespace-relative function calls
                 //if the file has a function with this name
-                if (file.parser.references.functionStatementLookup.get(lowerFunctionName) !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/dot-notation
+                if (file['_cachedLookups'].functionStatementMap.get(lowerFunctionName)) {
                     files.push(file);
                 }
             }
@@ -1138,55 +1407,142 @@ class Program {
         return files;
     }
     /**
-     * Find a list of files in the program that have a function with the given name (case INsensitive)
+     * Find a list of files in the program that have a class with the given name (case INsensitive)
      */
     findFilesForClass(className) {
         const files = [];
         const lowerClassName = className.toLowerCase();
         //find every file with this class defined
         for (const file of Object.values(this.files)) {
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 //TODO handle namespace-relative classes
                 //if the file has a function with this name
-                if (file.parser.references.classStatementLookup.get(lowerClassName) !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/dot-notation
+                if (file['_cachedLookups'].classStatementMap.get(lowerClassName) !== undefined) {
                     files.push(file);
                 }
             }
         }
         return files;
     }
+    findFilesForNamespace(name) {
+        const files = [];
+        const lowerName = name.toLowerCase();
+        //find every file with this class defined
+        for (const file of Object.values(this.files)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
+                // eslint-disable-next-line @typescript-eslint/dot-notation
+                if (file['_cachedLookups'].namespaceStatements.find((x) => {
+                    const namespaceName = x.name.toLowerCase();
+                    return (
+                    //the namespace name matches exactly
+                    namespaceName === lowerName ||
+                        //the full namespace starts with the name (honoring the part boundary)
+                        namespaceName.startsWith(lowerName + '.'));
+                })) {
+                    files.push(file);
+                }
+            }
+        }
+        return files;
+    }
+    findFilesForEnum(name) {
+        const files = [];
+        const lowerName = name.toLowerCase();
+        //find every file with this enum defined
+        for (const file of Object.values(this.files)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
+                // eslint-disable-next-line @typescript-eslint/dot-notation
+                if (file['_cachedLookups'].enumStatementMap.get(lowerName)) {
+                    files.push(file);
+                }
+            }
+        }
+        return files;
+    }
+    /**
+     * Modify a parsed manifest map by reading `bs_const` and injecting values from `options.manifest.bs_const`
+     * @param parsedManifest The manifest map to read from and modify
+     */
+    buildBsConstsIntoParsedManifest(parsedManifest) {
+        var _a, _b;
+        // Lift the bs_consts defined in the manifest
+        let bsConsts = (0, Manifest_1.getBsConst)(parsedManifest, false);
+        // Override or delete any bs_consts defined in the bs config
+        for (const key in (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.manifest) === null || _b === void 0 ? void 0 : _b.bs_const) {
+            const value = this.options.manifest.bs_const[key];
+            if (value === null) {
+                bsConsts.delete(key);
+            }
+            else {
+                bsConsts.set(key, value);
+            }
+        }
+        // convert the new list of bs consts back into a string for the rest of the down stream systems to use
+        let constString = '';
+        for (const [key, value] of bsConsts) {
+            constString += `${constString !== '' ? ';' : ''}${key}=${value.toString()}`;
+        }
+        // Set the updated bs_const value
+        parsedManifest.set('bs_const', constString);
+    }
+    /**
+     * Try to find and load the manifest into memory
+     * @param manifestFileObj A pointer to a potential manifest file object found during loading
+     * @param replaceIfAlreadyLoaded should we overwrite the internal `_manifest` if it already exists
+     */
+    loadManifest(manifestFileObj, replaceIfAlreadyLoaded = true) {
+        //if we already have a manifest instance, and should not replace...then don't replace
+        if (!replaceIfAlreadyLoaded && this._manifest) {
+            return;
+        }
+        let manifestPath = manifestFileObj
+            ? manifestFileObj.src
+            : path.join(this.options.rootDir, 'manifest');
+        try {
+            // we only load this manifest once, so do it sync to improve speed downstream
+            const contents = fsExtra.readFileSync(manifestPath, 'utf-8');
+            const parsedManifest = (0, Manifest_1.parseManifest)(contents);
+            this.buildBsConstsIntoParsedManifest(parsedManifest);
+            this._manifest = parsedManifest;
+        }
+        catch (e) {
+            this._manifest = new Map();
+        }
+    }
     /**
      * Get a map of the manifest information
      */
     getManifest() {
         if (!this._manifest) {
-            //load the manifest file.
-            //TODO update this to get the manifest from the files array or require it in the options...we shouldn't assume the location of the manifest
-            let manifestPath = path.join(this.options.rootDir, 'manifest');
-            let contents;
-            try {
-                //we only load this manifest once, so do it sync to improve speed downstream
-                contents = fsExtra.readFileSync(manifestPath, 'utf-8');
-                this._manifest = Manifest_1.parseManifest(contents);
-            }
-            catch (err) {
-                this._manifest = new Map();
-            }
+            this.loadManifest();
         }
         return this._manifest;
     }
     dispose() {
-        var _a, _b;
-        for (const key in this.files) {
-            const file = this.files[key];
-            (_a = file.dispose) === null || _a === void 0 ? void 0 : _a.call(file);
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        this.plugins.emit('beforeProgramDispose', { program: this });
+        for (let filePath in this.files) {
+            (_b = (_a = this.files[filePath]) === null || _a === void 0 ? void 0 : _a.dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
         }
         for (let name in this.scopes) {
-            (_b = this.scopes[name]) === null || _b === void 0 ? void 0 : _b.dispose();
+            (_d = (_c = this.scopes[name]) === null || _c === void 0 ? void 0 : _c.dispose) === null || _d === void 0 ? void 0 : _d.call(_c);
         }
-        this.globalScope.dispose();
-        this.dependencyGraph.dispose();
+        (_f = (_e = this.globalScope) === null || _e === void 0 ? void 0 : _e.dispose) === null || _f === void 0 ? void 0 : _f.call(_e);
+        (_h = (_g = this.dependencyGraph) === null || _g === void 0 ? void 0 : _g.dispose) === null || _h === void 0 ? void 0 : _h.call(_g);
     }
 }
 exports.Program = Program;
+class ProvideFileEventInternal {
+    constructor(program, srcPath, destPath, data, fileFactory) {
+        var _a;
+        this.program = program;
+        this.srcPath = srcPath;
+        this.destPath = destPath;
+        this.data = data;
+        this.fileFactory = fileFactory;
+        this.files = [];
+        this.srcExtension = (_a = path.extname(srcPath)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    }
+}
 //# sourceMappingURL=Program.js.map