brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/Program.js

@@ -7,32 +7,61 @@ 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 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 thenby_1 = require("thenby");
+const CrossScopeValidator_1 = require("./CrossScopeValidator");
+const DiagnosticManager_1 = require("./DiagnosticManager");
+const ProgramValidator_1 = require("./bscPlugin/validation/ProgramValidator");
+const SymbolTable_1 = require("./SymbolTable");
+const ReferenceType_1 = require("./types/ReferenceType");
+const helpers_1 = require("./types/helpers");
+const CallExpressionInfo_1 = require("./bscPlugin/CallExpressionInfo");
+const SignatureHelpUtil_1 = require("./bscPlugin/SignatureHelpUtil");
+const Sequencer_1 = require("./common/Sequencer");
+const deferred_1 = require("./deferred");
+const roFunctionType_1 = require("./types/roFunctionType");
+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 +69,37 @@ 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.globalScope = undefined;
+        this.fileSymbolInformation = new Map();
+        /**
+         *  Map of typetime symbols which depend upon the key symbol
          */
-        this.diagnostics = [];
+        this.symbolDependencies = new Map();
         /**
-         * A map of every file loaded ino this program, indexed by its lower-case pkgPath
+         * Symbol Table for storing custom component types
+         * This is a sibling to the global table (as Components can be used/referenced anywhere)
+         * Keeping custom components out of the global table and in a specific symbol table
+         * compartmentalizes their use
          */
-        this.pkgMap = {};
+        this.componentsTable = new SymbolTable_1.SymbolTable('Custom Components');
         /**
-         * 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 original file location
          */
         this.files = {};
+        /**
+         * A map of every file loaded into this program, indexed by its destPath
+         */
+        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 +108,184 @@ 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
+         * Map <componentKey, componentName>
+         */
+        this.componentSymbolsToUpdate = new Map();
+        this.crossScopeValidation = new CrossScopeValidator_1.CrossScopeValidator(this);
+        this.isFirstValidation = true;
+        this.validationDetails = {
+            brsFilesValidated: [],
+            xmlFilesValidated: [],
+            changedSymbols: new Map(),
+            changedComponentTypes: [],
+            scopesToValidate: [],
+            filesToBeValidatedInScopeContext: new Set()
+        };
+        this.lastValidationInfo = {
+            brsFilesSrcPath: new Set(),
+            xmlFilesSrcPath: new Set(),
+            scopeNames: new Set(),
+            componentsRebuilt: new Set()
+        };
+        /**
+         * Counter used to track which validation run is being logged
+         */
+        this.validationRunSequence = 1;
+        /**
+         * How many milliseconds can pass while doing synchronous operations in validate before we register a short timeout (i.e. yield to the event loop)
+         */
+        this.validationMinSyncDuration = 75;
+        this.getFilePathCache = new Map();
+        this.sortedScopeNames = undefined;
+        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();
+        //try to find a location for the diagnostic if it doesn't have one
+        this.diagnostics.locationResolver = (args) => {
+            //find the first xml scope for this diagnostic
+            for (let context of args.contexts) {
+                if ((0, reflection_1.isXmlScope)(context.scope) && (0, reflection_1.isXmlFile)(context.scope.xmlFile)) {
+                    return util_1.util.createLocation(0, 0, 0, 100, context.scope.xmlFile.srcPath);
+                }
+            }
+            //we couldn't find an xml scope for this, so try to find the manifest file instead
+            const manifest = this.getFile('manifest', false);
+            if (manifest) {
+                return util_1.util.createLocation(0, 0, 0, 100, manifest.srcPath);
+            }
+            //if we still don't have a manifest, try to find the first file in the program
+            for (const key in this.files) {
+                if ((0, reflection_1.isBrsFile)(this.files[key]) || (0, reflection_1.isXmlFile)(this.files[key])) {
+                    return util_1.util.createLocation(0, 0, 0, 100, this.files[key].srcPath);
+                }
+            }
+            this.logger.warn(`Unable to find a location for the diagnostic.`, args);
+            //we couldn't find any locations for the file, so just return undefined
+            return undefined;
+        };
+        // initialize the diagnostics Manager
+        this.diagnostics.logger = this.logger;
+        this.diagnostics.options = this.options;
+        this.diagnostics.program = this;
         //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();
+        this.globalScope.symbolTable.addSibling(this.componentsTable);
         //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();
+            nodeType.isBuiltIn = true;
+            if (nodeData.name === 'Node') {
+                // Add `roSGNode` as shorthand for `roSGNodeNode`
+                this.globalScope.symbolTable.addSymbol('roSGNode', { description: nodeData.description, isBuiltIn: true }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+            }
+            this.globalScope.symbolTable.addSymbol(nodeName, { description: nodeData.description, isBuiltIn: true }, 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
+        const builtInSymbolData = { isBuiltIn: true };
+        this.globalScope.symbolTable.addSymbol('boolean', builtInSymbolData, BooleanType_1.BooleanType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('double', builtInSymbolData, DoubleType_1.DoubleType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('dynamic', builtInSymbolData, DynamicType_1.DynamicType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('float', builtInSymbolData, FloatType_1.FloatType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('function', builtInSymbolData, FunctionType_1.FunctionType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('integer', builtInSymbolData, IntegerType_1.IntegerType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('longinteger', builtInSymbolData, LongIntegerType_1.LongIntegerType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('object', builtInSymbolData, ObjectType_1.ObjectType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('string', builtInSymbolData, StringType_1.StringType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('void', builtInSymbolData, 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, Object.assign(Object.assign({}, builtInSymbolData), { description: callable.shortDescription }), callable.type, 1 /* SymbolTypeFlag.runtime */);
+        }
+        for (const ifaceData of Object.values(roku_types_1.interfaces)) {
+            const ifaceType = new InterfaceType_1.InterfaceType(ifaceData.name);
+            ifaceType.addBuiltInInterfaces();
+            ifaceType.isBuiltIn = true;
+            this.globalScope.symbolTable.addSymbol(ifaceData.name, Object.assign(Object.assign({}, builtInSymbolData), { description: ifaceData.description }), ifaceType, 2 /* SymbolTypeFlag.typetime */);
+        }
+        for (const componentData of Object.values(roku_types_1.components)) {
+            let roComponentType;
+            const lowerComponentName = componentData.name.toLowerCase();
+            if (lowerComponentName === 'rosgnode') {
+                // we will add `roSGNode` as shorthand for `roSGNodeNode`, since all roSgNode components are SceneGraph nodes
+                continue;
+            }
+            if (lowerComponentName === 'rofunction') {
+                roComponentType = new roFunctionType_1.roFunctionType();
+            }
+            else {
+                roComponentType = new InterfaceType_1.InterfaceType(componentData.name);
+            }
+            roComponentType.addBuiltInInterfaces();
+            roComponentType.isBuiltIn = true;
+            this.globalScope.symbolTable.addSymbol(componentData.name, Object.assign(Object.assign({}, builtInSymbolData), { description: componentData.description }), roComponentType, 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 eventType = new InterfaceType_1.InterfaceType(eventData.name);
+            eventType.addBuiltInInterfaces();
+            eventType.isBuiltIn = true;
+            this.globalScope.symbolTable.addSymbol(eventData.name, Object.assign(Object.assign({}, builtInSymbolData), { description: eventData.description }), eventType, 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 +300,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 +311,15 @@ 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
-        });
+        delete this.sortedScopeNames;
+    }
+    removeScope(scope) {
+        if (this.scopes[scope.name]) {
+            delete this.scopes[scope.name];
+            delete this.sortedScopeNames;
+        }
     }
     /**
      * Get the component with the specified name
@@ -129,19 +328,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 +363,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 +390,84 @@ 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;
+        const componentKey = this.getComponentKey(xmlFile);
+        const componentName = (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text;
+        if (this.componentSymbolsToUpdate.has(componentKey)) {
+            return;
+        }
+        this.componentSymbolsToUpdate.set(componentKey, componentName);
+    }
+    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();
+    }
+    /**
+     * Resolves 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] || [];
+        const previousComponentType = this.componentsTable.getSymbolType(symbolName, { flags: 2 /* SymbolTypeFlag.typetime */ });
+        // Remove any existing symbols that match
+        this.componentsTable.removeSymbol(symbolName);
+        if (components.length > 0) {
+            // There is a component that can be added - use it.
+            const componentScope = components[0].scope;
+            this.componentsTable.removeSymbol(symbolName);
+            componentScope.linkSymbolTable();
+            const componentType = componentScope.getComponentType();
+            if (componentType) {
+                this.componentsTable.addSymbol(symbolName, {}, componentType, 2 /* SymbolTypeFlag.typetime */);
+            }
+            const typeData = {};
+            const isSameAsPrevious = previousComponentType && componentType.isEqual(previousComponentType, typeData);
+            const isComponentTypeDifferent = !previousComponentType || (0, reflection_1.isReferenceType)(previousComponentType) || !isSameAsPrevious;
+            componentScope.unlinkSymbolTable();
+            return isComponentTypeDifferent;
+        }
+        // There was a previous component type, but no new one, so it's different
+        return !!previousComponentType;
+    }
+    /**
+     * Adds a reference type to the global symbol table with the first component in this.components to have the same name as the component in the file
+     * This is so on a first validation, these types can be resolved in teh future (eg. when the actual component is created)
+     * If we don't add reference types at this top level, they will be created at the file level, and will never get resolved
+     * @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')
+     */
+    addComponentReferenceType(componentKey, componentName) {
+        const symbolName = componentName ? util_1.util.getSgNodeTypeName(componentName) : undefined;
+        if (!symbolName) {
+            return;
+        }
+        const components = this.components[componentKey] || [];
+        if (components.length > 0) {
+            // There is a component that can be added,
+            if (!this.componentsTable.hasSymbol(symbolName, 2 /* SymbolTypeFlag.typetime */)) {
+                // it doesn't already exist in the table
+                const componentRefType = new ReferenceType_1.ReferenceType(symbolName, symbolName, 2 /* SymbolTypeFlag.typetime */, () => this.componentsTable);
+                if (componentRefType) {
+                    this.componentsTable.addSymbol(symbolName, {}, componentRefType, 2 /* SymbolTypeFlag.typetime */);
+                }
+            }
+        }
+        else {
+            // there is no component. remove from table
+            this.componentsTable.removeSymbol(symbolName);
+        }
     }
     /**
      * re-attach the dependency graph with a new key for any component who changed
@@ -179,6 +481,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 +493,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 +504,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 +519,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 +548,178 @@ class Program {
      * Update internal maps with this file reference
      */
     assignFile(file) {
+        const fileAddEvent = {
+            file: file,
+            program: this
+        };
+        this.plugins.emit('beforeAddFile', fileAddEvent);
         this.files[file.srcPath.toLowerCase()] = file;
-        this.pkgMap[file.pkgPath.toLowerCase()] = file;
+        this.destMap.set(file.destPath.toLowerCase(), file);
+        this.plugins.emit('afterAddFile', 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)
-            }
-            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:/`)
-            }
-            else {
-                srcPath = util_1.standardizePath `${this.options.rootDir}/${fileParam}`;
-                pkgPath = util_1.util.sanitizePkgPath(fileParam);
-            }
-            //is a FileObj
-        }
-        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');
+    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);
+                this.removeFile(srcPath, true, true);
             }
-            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/')) {
+            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
+                }));
+            }
+            //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', brsFile.dependencyGraphKey);
+                    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)) {
+                    this.plugins.emit('beforeProvideScope', {
+                        program: this,
+                        scope: undefined
+                    });
+                    //create a new scope for this xml file
+                    let scope = new XmlScope_1.XmlScope(file, this);
+                    this.addScope(scope);
+                    //register this componet now that we have parsed it and know its component name
+                    this.registerComponent(file, scope);
+                    this.plugins.emit('provideScope', {
+                        program: this,
+                        scope: scope
+                    });
+                    //notify plugins that the scope is created and the component is registered
+                    this.plugins.emit('afterProvideScope', {
+                        program: this,
+                        scope: scope
+                    });
                 }
-                //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
-                });
-            }
-            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
-                });
             }
-            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;
-            }
-            return file;
+            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 {
+            let param = fileParam;
+            if (param.src) {
+                srcPath = (0, util_1.standardizePath) `${param.src}`;
+            }
+            if (param.srcPath) {
+                srcPath = (0, util_1.standardizePath) `${param.srcPath}`;
+            }
+            if (param.dest) {
+                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.dest)}`;
+            }
+            if (param.pkgPath) {
+                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.pkgPath)}`;
+            }
+        }
+        //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 +730,574 @@ class Program {
             const sourceScope = new Scope_1.Scope('source', this, 'scope:source');
             sourceScope.attachDependencyGraph(this.dependencyGraph);
             this.addScope(sourceScope);
+            this.plugins.emit('afterProvideScope', {
+                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('beforeRemoveFile', 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', {
+                this.logger.debug('Removing associated scope', scope.name);
+                const scopeRemoveEvent = {
                     program: this,
                     scope: scope
-                });
+                };
+                this.plugins.emit('beforeRemoveScope', scopeRemoveEvent);
+                this.plugins.emit('removeScope', scopeRemoveEvent);
                 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
-                });
+                this.removeScope(this.scopes[file.destPath]);
+                this.plugins.emit('afterRemoveScope', scopeRemoveEvent);
             }
             //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)) {
+                this.logger.debug('Removing file symbol info', file.srcPath);
+                if (!keepSymbolInformation) {
+                    this.fileSymbolInformation.delete(file.pkgPath);
+                }
+                this.crossScopeValidation.clearResolutionsForFile(file);
+            }
+            this.diagnostics.clearForFile(file.srcPath);
             //if this is a component, remove it from our components map
-            if (reflection_1.isXmlFile(file)) {
+            if ((0, reflection_1.isXmlFile)(file)) {
+                this.logger.debug('Unregistering component', file.srcPath);
                 this.unregisterComponent(file);
             }
-            this.plugins.emit('afterFileDispose', {
-                program: this,
-                file: file
-            });
+            this.logger.debug('Disposing file', file.srcPath);
+            //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('afterRemoveFile', event);
         }
     }
-    /**
-     * 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);
+    validate(options) {
+        var _a;
+        const validationRunId = this.validationRunSequence++;
+        let previousValidationPromise = this.validatePromise;
+        const deferred = new deferred_1.Deferred();
+        if (options === null || options === void 0 ? void 0 : options.async) {
+            //we're async, so create a new promise chain to resolve after this validation is done
+            this.validatePromise = Promise.resolve(previousValidationPromise).then(() => {
+                return deferred.promise;
+            });
+            //we are not async but there's a pending promise, then we cannot run this validation
         }
-        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);
-            }
+        else if (previousValidationPromise !== undefined) {
+            throw new Error('Cannot run synchronous validation while an async validation is in progress');
         }
-    }
-    /**
-     * 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', {
+        let beforeValidateProgramWasEmitted = false;
+        const brsFilesValidated = this.validationDetails.brsFilesValidated;
+        const xmlFilesValidated = this.validationDetails.xmlFilesValidated;
+        const changedSymbols = this.validationDetails.changedSymbols;
+        const changedComponentTypes = this.validationDetails.changedComponentTypes;
+        const scopesToValidate = this.validationDetails.scopesToValidate;
+        const filesToBeValidatedInScopeContext = this.validationDetails.filesToBeValidatedInScopeContext;
+        //validate every file
+        let logValidateEnd = (status) => { };
+        //will be populated later on during the correspnding sequencer event
+        let filesToProcess;
+        const sequencer = new Sequencer_1.Sequencer({
+            name: 'program.validate',
+            cancellationToken: (_a = options === null || options === void 0 ? void 0 : options.cancellationToken) !== null && _a !== void 0 ? _a : new vscode_languageserver_1.CancellationTokenSource().token,
+            minSyncDuration: this.validationMinSyncDuration
+        });
+        //this sequencer allows us to run in both sync and async mode, depending on whether options.async is enabled.
+        //We use this to prevent starving the CPU during long validate cycles when running in a language server context
+        sequencer
+            .once('wait for previous run', () => {
+            //if running in async mode, return the previous validation promise to ensure we're only running one at a time
+            if (options === null || options === void 0 ? void 0 : options.async) {
+                return previousValidationPromise;
+            }
+        })
+            .once('before and on programValidate', () => {
+            logValidateEnd = this.logger.timeStart(logging_1.LogLevel.log, `Validating project${this.logger.logLevel > logging_1.LogLevel.log ? ` (run ${validationRunId})` : ''}`);
+            this.diagnostics.clearForTag(ProgramValidator_1.ProgramValidatorDiagnosticsTag);
+            this.plugins.emit('beforeValidateProgram', {
+                program: this
+            });
+            beforeValidateProgramWasEmitted = true;
+            this.plugins.emit('validateProgram', {
                 program: this
             });
-            //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) }));
+        })
+            .once('get files to be validated', () => {
+            filesToProcess = Object.values(this.files).sort((0, thenby_1.firstBy)(x => x.srcPath)).filter(x => !x.isValidated);
+            for (const file of filesToProcess) {
+                filesToBeValidatedInScopeContext.add(file);
+            }
+        })
+            .once('add component reference types', () => {
+            // Create reference component types for any component that changes
+            for (let [componentKey, componentName] of this.componentSymbolsToUpdate.entries()) {
+                this.addComponentReferenceType(componentKey, componentName);
+            }
+        })
+            .forEach('beforeValidateFile', () => filesToProcess, (file) => {
+            //run the beforeFilevalidate event for every unvalidated file
+            this.plugins.emit('beforeValidateFile', {
+                program: this,
+                file: file
+            });
+        })
+            .forEach('validateFile', () => filesToProcess, (file) => {
+            //run the validateFile event for every unvalidated file
+            this.plugins.emit('validateFile', {
+                program: this,
+                file: file
+            });
+            file.isValidated = true;
+            if ((0, reflection_1.isBrsFile)(file)) {
+                brsFilesValidated.push(file);
+            }
+            else if ((0, reflection_1.isXmlFile)(file)) {
+                xmlFilesValidated.push(file);
+            }
+        })
+            .forEach('afterValidateFile', () => filesToProcess, (file) => {
+            //run the validateFile event for every unvalidated file
+            this.plugins.emit('afterValidateFile', {
+                program: this,
+                file: file
+            });
+        })
+            .forEach('do deferred component creation', () => [...brsFilesValidated, ...xmlFilesValidated], (file) => {
+            if ((0, reflection_1.isXmlFile)(file)) {
+                this.addDeferredComponentTypeSymbolCreation(file);
+            }
+            else if ((0, reflection_1.isBrsFile)(file)) {
+                const fileHasChanges = file.providedSymbols.changes.get(1 /* SymbolTypeFlag.runtime */).size > 0 || file.providedSymbols.changes.get(2 /* SymbolTypeFlag.typetime */).size > 0;
+                if (fileHasChanges) {
+                    for (const scope of this.getScopesForFile(file)) {
+                        if ((0, reflection_1.isXmlScope)(scope) && this.doesXmlFileRequireProvidedSymbols(scope.xmlFile, file.providedSymbols.changes)) {
+                            this.addDeferredComponentTypeSymbolCreation(scope.xmlFile);
+                        }
+                    }
                 }
-                //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', {
-                        program: this,
-                        file: file
-                    });
+            }
+        })
+            .once('build component types for any component that changes', () => {
+            this.logger.time(logging_1.LogLevel.info, ['Build component types'], () => {
+                this.logger.debug(`Component Symbols to update:`, [...this.componentSymbolsToUpdate.entries()].sort());
+                this.lastValidationInfo.componentsRebuilt = new Set();
+                for (let [componentKey, componentName] of this.componentSymbolsToUpdate.entries()) {
+                    this.lastValidationInfo.componentsRebuilt.add(componentName === null || componentName === void 0 ? void 0 : componentName.toLowerCase());
+                    if (this.updateComponentSymbolInGlobalScope(componentKey, componentName)) {
+                        changedComponentTypes.push(util_1.util.getSgNodeTypeName(componentName).toLowerCase());
+                    }
+                }
+                this.componentSymbolsToUpdate.clear();
+            });
+        })
+            .once('track and update type-time and runtime symbol dependencies and changes', () => {
+            var _a, _b, _c, _d;
+            const changedSymbolsMapArr = (_a = [...brsFilesValidated, ...xmlFilesValidated]) === null || _a === void 0 ? void 0 : _a.map(f => {
+                if ((0, reflection_1.isBrsFile)(f)) {
+                    return f.providedSymbols.changes;
+                }
+                return null;
+            }).filter(x => x);
+            // update the map of typetime dependencies
+            for (const file of brsFilesValidated) {
+                for (const [symbolName, provided] of file.providedSymbols.symbolMap.get(2 /* SymbolTypeFlag.typetime */).entries()) {
+                    // clear existing dependencies
+                    for (const values of this.symbolDependencies.values()) {
+                        values.delete(symbolName);
+                    }
+                    // map types to the set of types that depend upon them
+                    for (const dependentSymbol of (_c = (_b = provided.requiredSymbolNames) === null || _b === void 0 ? void 0 : _b.values()) !== null && _c !== void 0 ? _c : []) {
+                        const dependentSymbolLower = dependentSymbol.toLowerCase();
+                        if (!this.symbolDependencies.has(dependentSymbolLower)) {
+                            this.symbolDependencies.set(dependentSymbolLower, new Set());
+                        }
+                        const symbolsDependentUpon = this.symbolDependencies.get(dependentSymbolLower);
+                        symbolsDependentUpon.add(symbolName);
+                    }
                 }
             }
-            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
-                        });
+            for (const flag of [1 /* SymbolTypeFlag.runtime */, 2 /* SymbolTypeFlag.typetime */]) {
+                const changedSymbolsSetArr = changedSymbolsMapArr.map(symMap => symMap.get(flag));
+                const changedSymbolSet = new Set();
+                for (const changeSet of changedSymbolsSetArr) {
+                    for (const change of changeSet) {
+                        changedSymbolSet.add(change);
+                    }
+                }
+                if (!changedSymbols.has(flag)) {
+                    changedSymbols.set(flag, changedSymbolSet);
+                }
+                else {
+                    changedSymbols.set(flag, new Set([...changedSymbols.get(flag), ...changedSymbolSet]));
+                }
+            }
+            // update changed symbol set with any changed component
+            for (const changedComponentType of changedComponentTypes) {
+                changedSymbols.get(2 /* SymbolTypeFlag.typetime */).add(changedComponentType);
+            }
+            // Add any additional types that depend on a changed type
+            // as each iteration of the loop might add new types, need to keep checking until nothing new is added
+            const dependentTypesChanged = new Set();
+            let foundDependentTypes = false;
+            const changedTypeSymbols = changedSymbols.get(2 /* SymbolTypeFlag.typetime */);
+            do {
+                foundDependentTypes = false;
+                const allChangedTypesSofar = [...Array.from(changedTypeSymbols), ...Array.from(dependentTypesChanged)];
+                for (const changedSymbol of allChangedTypesSofar) {
+                    const symbolsDependentUponChangedSymbol = (_d = this.symbolDependencies.get(changedSymbol)) !== null && _d !== void 0 ? _d : [];
+                    for (const symbolName of symbolsDependentUponChangedSymbol) {
+                        if (!changedTypeSymbols.has(symbolName) && !dependentTypesChanged.has(symbolName)) {
+                            foundDependentTypes = true;
+                            dependentTypesChanged.add(symbolName);
+                        }
                     }
                 }
+            } while (foundDependentTypes);
+            changedSymbols.set(2 /* SymbolTypeFlag.typetime */, new Set([...changedSymbols.get(2 /* SymbolTypeFlag.typetime */), ...changedTypeSymbols, ...dependentTypesChanged]));
+            this.lastValidationInfo.brsFilesSrcPath = new Set(this.validationDetails.brsFilesValidated.map(f => { var _a, _b; return (_b = (_a = f.srcPath) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : ''; }));
+            this.lastValidationInfo.xmlFilesSrcPath = new Set(this.validationDetails.xmlFilesValidated.map(f => { var _a, _b; return (_b = (_a = f.srcPath) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : ''; }));
+            // can reset filesValidatedList, because they are no longer needed
+            this.validationDetails.brsFilesValidated = [];
+            this.validationDetails.xmlFilesValidated = [];
+        })
+            .once('tracks changed symbols and prepares files and scopes for validation', () => {
+            if (this.options.logLevel === logging_1.LogLevel.debug) {
+                const changedRuntime = Array.from(changedSymbols.get(1 /* SymbolTypeFlag.runtime */)).sort();
+                this.logger.debug('Changed Symbols (runTime):', changedRuntime.join(', '));
+                const changedTypetime = Array.from(changedSymbols.get(2 /* SymbolTypeFlag.typetime */)).sort();
+                this.logger.debug('Changed Symbols (typeTime):', changedTypetime.join(', '));
+            }
+            const didComponentChange = changedComponentTypes.length > 0;
+            const didProvidedSymbolChange = changedSymbols.get(1 /* SymbolTypeFlag.runtime */).size > 0 || changedSymbols.get(2 /* SymbolTypeFlag.typetime */).size > 0;
+            const scopesToCheck = this.getScopesForCrossScopeValidation(didComponentChange, didProvidedSymbolChange);
+            this.crossScopeValidation.buildComponentsMap();
+            this.logger.time(logging_1.LogLevel.info, ['addDiagnosticsForScopes'], () => {
+                this.crossScopeValidation.addDiagnosticsForScopes(scopesToCheck);
             });
-            this.detectDuplicateComponentNames();
-            this.plugins.emit('afterProgramValidate', {
-                program: this
+            const filesToRevalidate = this.crossScopeValidation.getFilesRequiringChangedSymbol(scopesToCheck, changedSymbols);
+            for (const file of filesToRevalidate) {
+                filesToBeValidatedInScopeContext.add(file);
+            }
+            this.currentScopeValidationOptions = {
+                filesToBeValidatedInScopeContext: filesToBeValidatedInScopeContext,
+                changedSymbols: changedSymbols,
+                changedFiles: Array.from(filesToBeValidatedInScopeContext),
+                initialValidation: this.isFirstValidation
+            };
+            //can reset changedComponent types
+            this.validationDetails.changedComponentTypes = [];
+        })
+            .forEach('invalidate affected scopes', () => filesToBeValidatedInScopeContext, (file) => {
+            if ((0, reflection_1.isBrsFile)(file)) {
+                file.validationSegmenter.unValidateAllSegments();
+                for (const scope of this.getScopesForFile(file)) {
+                    scope.invalidate();
+                }
+            }
+        })
+            .once('checking scopes to validate', () => {
+            //sort the scope names so we get consistent results
+            for (const scopeName of this.getSortedScopeNames()) {
+                let scope = this.scopes[scopeName];
+                if (scope.shouldValidate(this.currentScopeValidationOptions)) {
+                    scopesToValidate.push(scope);
+                }
+            }
+            this.lastValidationInfo.scopeNames = new Set(scopesToValidate.map(s => { var _a, _b; return (_b = (_a = s.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : ''; }));
+        })
+            .forEach('beforeScopeValidate', () => scopesToValidate, (scope) => {
+            this.plugins.emit('beforeValidateScope', {
+                program: this,
+                scope: scope
+            });
+        })
+            .forEach('validate scope', () => scopesToValidate, (scope) => {
+            scope.validate(this.currentScopeValidationOptions);
+        })
+            .forEach('afterValidateScope', () => scopesToValidate, (scope) => {
+            this.plugins.emit('afterValidateScope', {
+                program: this,
+                scope: scope
             });
+        })
+            .once('detect duplicate component names', () => {
+            this.detectDuplicateComponentNames();
+            this.isFirstValidation = false;
+            // can reset other validation details
+            this.validationDetails.changedSymbols = new Map();
+            this.validationDetails.scopesToValidate = [];
+            this.validationDetails.filesToBeValidatedInScopeContext = new Set();
+        })
+            .onCancel(() => {
+            logValidateEnd('cancelled');
+        })
+            .onSuccess(() => {
+            logValidateEnd();
+        })
+            .onComplete(() => {
+            var _a, _b;
+            //if we emitted the beforeValidateProgram hook, emit the afterValidateProgram hook as well
+            if (beforeValidateProgramWasEmitted) {
+                const wasCancelled = (_b = (_a = options === null || options === void 0 ? void 0 : options.cancellationToken) === null || _a === void 0 ? void 0 : _a.isCancellationRequested) !== null && _b !== void 0 ? _b : false;
+                this.plugins.emit('afterValidateProgram', {
+                    program: this,
+                    wasCancelled: wasCancelled
+                });
+            }
+            //log all the sequencer timing metrics if `info` logging is enabled
+            this.logger.info(sequencer.formatMetrics({
+                header: 'Program.validate metrics:',
+                //only include loop iterations if `debug` logging is enabled
+                includeLoopIterations: this.logger.isLogLevelEnabled(logging_1.LogLevel.debug)
+            }));
+            //regardless of the success of the validation, mark this run as complete
+            deferred.resolve();
+            //clear the validatePromise which means we're no longer running a validation
+            this.validatePromise = undefined;
         });
+        //run the sequencer in async mode if enabled
+        if (options === null || options === void 0 ? void 0 : options.async) {
+            return sequencer.run();
+            //run the sequencer in sync mode
+        }
+        else {
+            return sequencer.runSync();
+        }
+    }
+    getScopesForCrossScopeValidation(someComponentTypeChanged, didProvidedSymbolChange) {
+        const scopesForCrossScopeValidation = [];
+        for (let scopeName of this.getSortedScopeNames()) {
+            let scope = this.scopes[scopeName];
+            if (this.globalScope === scope) {
+                continue;
+            }
+            if (someComponentTypeChanged) {
+                scopesForCrossScopeValidation.push(scope);
+            }
+            if (didProvidedSymbolChange && !scope.isValidated) {
+                scopesForCrossScopeValidation.push(scope);
+            }
+        }
+        return scopesForCrossScopeValidation;
+    }
+    doesXmlFileRequireProvidedSymbols(file, providedSymbolsByFlag) {
+        for (const required of file.requiredSymbols) {
+            const symbolNameLower = required.name.toLowerCase();
+            const requiredSymbolIsProvided = providedSymbolsByFlag.get(required.flags).has(symbolNameLower);
+            if (requiredSymbolIsProvided) {
+                return true;
+            }
+        }
+        return false;
     }
     /**
      * 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)), { location: xmlFile.componentName.location, relatedInformation: xmlFiles.filter(x => x !== xmlFile).map(x => {
                             return {
-                                location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(xmlFile.srcPath).toString(), x.componentName.range),
+                                location: x.componentName.location,
                                 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 (this.getFilePathCache.has(filePath)) {
+            const cachedFilePath = this.getFilePathCache.get(filePath);
+            if (cachedFilePath.isDestMap) {
+                return this.destMap.get(cachedFilePath.path);
+            }
+            return this.files[cachedFilePath.path];
+        }
         if (typeof filePath !== 'string') {
             return undefined;
+            //is the path absolute (or the `virtual:` prefix)
+        }
+        else if (/^(?:(?:virtual:[\/\\])|(?:\w:)|(?:[\/\\]))/gmi.exec(filePath)) {
+            const standardizedPath = (normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase();
+            this.getFilePathCache.set(filePath, { path: standardizedPath });
+            return this.files[standardizedPath];
         }
-        else if (path.isAbsolute(filePath)) {
-            return this.files[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
+        else if (util_1.util.isUriLike(filePath)) {
+            const path = vscode_uri_1.URI.parse(filePath).fsPath;
+            const standardizedPath = (normalizePath ? util_1.util.standardizePath(path) : path).toLowerCase();
+            this.getFilePathCache.set(filePath, { path: standardizedPath });
+            return this.files[standardizedPath];
         }
         else {
-            return this.pkgMap[(normalizePath ? util_1.util.sanitizePkgPath(filePath) : filePath).toLowerCase()];
+            const standardizedPath = (normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase();
+            this.getFilePathCache.set(filePath, { path: standardizedPath, isDestMap: true });
+            return this.destMap.get(standardizedPath);
+        }
+    }
+    /**
+     * Gets a sorted list of all scopeNames, always beginning with "global", "source", then any others in alphabetical order
+     */
+    getSortedScopeNames() {
+        if (!this.sortedScopeNames) {
+            this.sortedScopeNames = 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;
+            });
         }
+        return this.sortedScopeNames;
     }
     /**
      * 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,136 +1309,165 @@ 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 member of (_b = (_a = currentScope.xmlFile.ast.component) === null || _a === void 0 ? void 0 : _a.interfaceMembers) !== null && _b !== void 0 ? _b : []) {
-                if (reflection_1.isSGInterfaceFunction(member)) {
-                    const name = member.name;
-                    if (!filterName || name === filterName) {
-                        funcNames.add(name);
-                    }
+        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);
                 }
             }
             currentScope = currentScope.getParentScope();
         }
         //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: this.getScopesForFile(file),
+            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 = [];
         const file = this.getFile(srcPath);
         if (file) {
+            const fileUri = util_1.util.pathToUri(file === null || file === void 0 ? void 0 : file.srcPath);
             const diagnostics = this
                 //get all current diagnostics (filtered by diagnostic filters)
                 .getDiagnostics()
                 //only keep diagnostics related to this file
-                .filter(x => x.file === file)
+                .filter(x => { var _a; return ((_a = x.location) === null || _a === void 0 ? void 0 : _a.uri) === fileUri; })
                 //only keep diagnostics that touch this range
-                .filter(x => util_1.util.rangesIntersect(x.range, range));
+                .filter(x => util_1.util.rangesIntersectOrTouch(x.location.range, range));
             const scopes = this.getScopesForFile(file);
-            this.plugins.emit('onGetCodeActions', {
+            this.plugins.emit('beforeProvideCodeActions', {
+                program: this,
+                file: file,
+                range: range,
+                diagnostics: diagnostics,
+                scopes: scopes,
+                codeActions: codeActions
+            });
+            this.plugins.emit('provideCodeActions', {
+                program: this,
+                file: file,
+                range: range,
+                diagnostics: diagnostics,
+                scopes: scopes,
+                codeActions: codeActions
+            });
+            this.plugins.emit('afterProvideCodeActions', {
                 program: this,
                 file: file,
                 range: range,
@@ -770,8 +1484,20 @@ class Program {
     getSemanticTokens(srcPath) {
         const file = this.getFile(srcPath);
         if (file) {
+            this.plugins.emit('beforeProvideSemanticTokens', {
+                program: this,
+                file: file,
+                scopes: this.getScopesForFile(file),
+                semanticTokens: undefined
+            });
             const result = [];
-            this.plugins.emit('onGetSemanticTokens', {
+            this.plugins.emit('provideSemanticTokens', {
+                program: this,
+                file: file,
+                scopes: this.getScopesForFile(file),
+                semanticTokens: result
+            });
+            this.plugins.emit('afterProvideSemanticTokens', {
                 program: this,
                 file: file,
                 scopes: this.getScopesForFile(file),
@@ -780,363 +1506,262 @@ class Program {
             return result;
         }
     }
-    getSignatureHelp(filepath, position) {
-        var _a;
-        let file = this.getFile(filepath);
-        if (!file || !reflection_1.isBrsFile(file)) {
+    getSignatureHelp(filePath, position) {
+        let file = this.getFile(filePath);
+        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, outDir = this.getOutDir()) {
+        return (0, util_1.standardizePath) `${outDir}/${file.pkgPath}`;
+    }
+    getOutDir(outDir) {
+        var _a, _b;
+        let result = (_a = outDir !== null && outDir !== void 0 ? outDir : this.options.outDir) !== null && _a !== void 0 ? _a : this.options.outDir;
+        if (!result) {
+            result = roku_deploy_1.rokuDeploy.getOptions(this.options).outDir;
         }
-        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 programEvent.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;
-                }
+        }
+        //sort the entries to make transpiling more deterministic
+        programEvent.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;
+            }
+        });
+        await this.plugins.emitAsync('beforePrepareProgram', programEvent);
+        await this.plugins.emitAsync('prepareProgram', programEvent);
+        const outDir = this.getOutDir();
+        const entries = [];
+        for (const file of files) {
+            const scope = this.getFirstScopeForFile(file);
+            //link the symbol table for all the files in this scope
+            scope === null || scope === void 0 ? void 0 : scope.linkSymbolTable();
+            //if the file doesn't have an editor yet, assign one now
+            if (!file.editor) {
+                file.editor = new Editor_1.Editor();
             }
-            index--;
+            const event = {
+                program: this,
+                file: file,
+                editor: file.editor,
+                scope: scope,
+                outputPath: this.getOutputPath(file, outDir)
+            };
+            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);
+            //unlink the symbolTable so the next loop iteration can link theirs
+            scope === null || scope === void 0 ? void 0 : scope.unlinkSymbolTable();
         }
-        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('serializeProgram', serializeProgramEvent);
+        // serialize each file
+        for (const file of files) {
+            let scope = this.getFirstScopeForFile(file);
+            //if the file doesn't have a scope, create a temporary scope for the file so it can depend on scope-level items
+            if (!scope) {
+                scope = new Scope_1.Scope(`temporary-for-${file.pkgPath}`, this);
+                scope.getAllFiles = () => [file];
+                scope.getOwnFiles = scope.getAllFiles;
             }
+            //link the symbol table for all the files in this scope
+            scope === null || scope === void 0 ? void 0 : scope.linkSymbolTable();
+            const event = {
+                program: this,
+                file: file,
+                scope: scope,
+                result: allFiles
+            };
+            await this.plugins.emitAsync('beforeSerializeFile', event);
+            await this.plugins.emitAsync('serializeFile', event);
+            await this.plugins.emitAsync('afterSerializeFile', event);
+            //unlink the symbolTable so the next loop iteration can link theirs
+            scope === null || scope === void 0 ? void 0 : scope.unlinkSymbolTable();
         }
-        return result;
+        this.plugins.emit('afterSerializeProgram', serializeProgramEvent);
+        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(outDir, files) {
+        const programEvent = await this.plugins.emitAsync('beforeWriteProgram', {
             program: this,
-            entries: entries
+            files: files,
+            outDir: outDir
         });
-        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 out directory
+        await fsExtra.emptyDir(outDir);
+        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, outDir),
+                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 outDir = this.getOutDir(options === null || options === void 0 ? void 0 : options.outDir);
+            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)
             });
+            //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(outDir, 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();
+            }
         });
-        //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));
+        this.logger.debug('Types Created', helpers_1.TypesCreated);
+        let totalTypesCreated = 0;
+        for (const key in helpers_1.TypesCreated) {
+            if (helpers_1.TypesCreated.hasOwnProperty(key)) {
+                totalTypesCreated += helpers_1.TypesCreated[key];
+            }
         }
-        await Promise.all(promises);
-        this.plugins.emit('afterProgramTranspile', {
-            program: this,
-            entries: entries
-        });
+        this.logger.info('Total Types Created', totalTypesCreated);
     }
     /**
      * Find a list of files in the program that have a function with the given name (case INsensitive)
@@ -1146,10 +1771,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);
                 }
             }
@@ -1157,55 +1783,144 @@ 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('beforeRemoveProgram', { 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);
+        this.plugins.emit('removeProgram', { program: this });
+        this.plugins.emit('afterRemoveProgram', { program: this });
     }
 }
 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