brighterscript 1.0.0-alpha.24 → 1.0.0-alpha.25

package/dist/Program.js

@@ -4,11 +4,8 @@ exports.Program = void 0;
 const assert = require("assert");
 const fsExtra = require("fs-extra");
 const path = require("path");
-const vscode_languageserver_1 = require("vscode-languageserver");
 const Scope_1 = require("./Scope");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
-const BrsFile_1 = require("./files/BrsFile");
-const XmlFile_1 = require("./files/XmlFile");
 const util_1 = require("./util");
 const XmlScope_1 = require("./XmlScope");
 const DiagnosticFilterer_1 = require("./DiagnosticFilterer");
@@ -20,20 +17,43 @@ 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/Parser");
-const TokenKind_1 = require("./lexer/TokenKind");
 const BscPlugin_1 = require("./bscPlugin/BscPlugin");
+const Editor_1 = require("./astUtils/Editor");
+const CallExpressionInfo_1 = require("./bscPlugin/CallExpressionInfo");
+const SignatureHelpUtil_1 = require("./bscPlugin/SignatureHelpUtil");
+const DiagnosticSeverityAdjuster_1 = require("./DiagnosticSeverityAdjuster");
+const IntegerType_1 = require("./types/IntegerType");
+const StringType_1 = require("./types/StringType");
+const SymbolTable_1 = require("./SymbolTable");
+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 AstEditor_1 = require("./astUtils/AstEditor");
-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 types_1 = require("./types");
+const BuiltInInterfaceAdder_1 = require("./types/BuiltInInterfaceAdder");
+const visitors_1 = require("./astUtils/visitors");
+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;
+        /**
+         * 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:
@@ -42,19 +62,32 @@ class Program {
          */
         this.dependencyGraph = new DependencyGraph_1.DependencyGraph();
         this.diagnosticFilterer = new DiagnosticFilterer_1.DiagnosticFilterer();
+        this.diagnosticAdjuster = new DiagnosticSeverityAdjuster_1.DiagnosticSeverityAdjuster();
+        /**
+         * A scope that contains all built-in global functions.
+         * All scopes should directly or indirectly inherit from this scope
+         */
+        this.globalScope = undefined;
         /**
          * A set of diagnostics. This does not include any of the scope diagnostics.
          * Should only be set from `this.validate()`
          */
         this.diagnostics = [];
+        this.fileSymbolInformation = new Map();
         /**
-         * A map of every file loaded ino this program, indexed by its lower-case pkgPath
+         * A map of every file loaded into this program, indexed by its original file location
          */
-        this.pkgMap = {};
+        this.files = {};
         /**
-         * A map of every file loaded into this program, indexed by its lower-case srcPath
+         * A map of every file loaded into this program, indexed by its destPath
          */
-        this.files = {};
+        this.destMap = new Map();
+        /**
+         * Plugins can contribute multiple virtual files for a single physical file.
+         * This collection links the virtual files back to the physical file that produced them.
+         * The key is the standardized and lower-cased srcPath
+         */
+        this.fileClusters = new Map();
         this.scopes = {};
         /**
          * A map of every component currently loaded into the program, indexed by the component name.
@@ -63,28 +96,118 @@ class Program {
          * but if you do, only ever use the component at index 0.
          */
         this.components = {};
+        /**
+         * Keeps a set of all the components that need to have their types updated during the current validation cycle
+         */
+        this.componentSymbolsToUpdate = new Set();
+        this.lastValidationInfo = new Map();
+        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.plugins = plugins || new PluginInterface_1.default([], { logger: this.logger });
         //inject the bsc plugin as the first plugin in the stack.
         this.plugins.addFirst(new BscPlugin_1.BscPlugin());
         //normalize the root dir path
         this.options.rootDir = util_1.util.getRootDir(this.options);
         this.createGlobalScope();
+        this.fileFactory = new Factory_1.FileFactory(this);
     }
     createGlobalScope() {
         //create the 'global' scope
         this.globalScope = new Scope_1.Scope('global', this, 'scope:global');
         this.globalScope.attachDependencyGraph(this.dependencyGraph);
         this.scopes.global = this.globalScope;
+        this.populateGlobalSymbolTable();
         //hardcode the files list for global scope to only contain the global file
         this.globalScope.getAllFiles = () => [globalCallables_1.globalFile];
+        globalCallables_1.globalFile.isValidated = true;
         this.globalScope.validate();
         //for now, disable validation of global scope because the global files have some duplicate method declarations
         this.globalScope.getDiagnostics = () => [];
         //TODO we might need to fix this because the isValidated clears stuff now
         this.globalScope.isValidated = true;
     }
+    recursivelyAddNodeToSymbolTable(nodeData) {
+        if (!nodeData) {
+            return;
+        }
+        let nodeType;
+        const nodeName = util_1.util.getSgNodeTypeName(nodeData.name);
+        if (!this.globalScope.symbolTable.hasSymbol(nodeName, SymbolTable_1.SymbolTypeFlag.typetime)) {
+            let parentNode;
+            if (nodeData.extends) {
+                const parentNodeData = roku_types_1.nodes[nodeData.extends.name.toLowerCase()];
+                try {
+                    parentNode = this.recursivelyAddNodeToSymbolTable(parentNodeData);
+                }
+                catch (error) {
+                    console.log(error, nodeData);
+                }
+            }
+            nodeType = new ComponentType_1.ComponentType(nodeData.name, parentNode);
+            nodeType.addBuiltInInterfaces();
+            if (nodeData.name === 'Node') {
+                // Add `roSGNode` as shorthand for `roSGNodeNode`
+                this.globalScope.symbolTable.addSymbol('roSGNode', { description: nodeData.description }, nodeType, SymbolTable_1.SymbolTypeFlag.typetime);
+            }
+            this.globalScope.symbolTable.addSymbol(nodeName, { description: nodeData.description }, nodeType, SymbolTable_1.SymbolTypeFlag.typetime);
+        }
+        else {
+            nodeType = this.globalScope.symbolTable.getSymbolType(nodeName, { flags: SymbolTable_1.SymbolTypeFlag.typetime });
+        }
+        return nodeType;
+    }
+    /**
+     * Do all setup required for the global symbol table.
+     */
+    populateGlobalSymbolTable() {
+        //Setup primitive types in global symbolTable
+        this.globalScope.symbolTable.addSymbol('boolean', undefined, BooleanType_1.BooleanType.instance, SymbolTable_1.SymbolTypeFlag.typetime);
+        this.globalScope.symbolTable.addSymbol('double', undefined, DoubleType_1.DoubleType.instance, SymbolTable_1.SymbolTypeFlag.typetime);
+        this.globalScope.symbolTable.addSymbol('dynamic', undefined, DynamicType_1.DynamicType.instance, SymbolTable_1.SymbolTypeFlag.typetime);
+        this.globalScope.symbolTable.addSymbol('float', undefined, FloatType_1.FloatType.instance, SymbolTable_1.SymbolTypeFlag.typetime);
+        this.globalScope.symbolTable.addSymbol('function', undefined, new FunctionType_1.FunctionType(), SymbolTable_1.SymbolTypeFlag.typetime);
+        this.globalScope.symbolTable.addSymbol('integer', undefined, IntegerType_1.IntegerType.instance, SymbolTable_1.SymbolTypeFlag.typetime);
+        this.globalScope.symbolTable.addSymbol('longinteger', undefined, LongIntegerType_1.LongIntegerType.instance, SymbolTable_1.SymbolTypeFlag.typetime);
+        this.globalScope.symbolTable.addSymbol('object', undefined, new ObjectType_1.ObjectType(), SymbolTable_1.SymbolTypeFlag.typetime);
+        this.globalScope.symbolTable.addSymbol('string', undefined, StringType_1.StringType.instance, SymbolTable_1.SymbolTypeFlag.typetime);
+        this.globalScope.symbolTable.addSymbol('void', undefined, VoidType_1.VoidType.instance, SymbolTable_1.SymbolTypeFlag.typetime);
+        BuiltInInterfaceAdder_1.BuiltInInterfaceAdder.getLookupTable = () => this.globalScope.symbolTable;
+        for (const callable of globalCallables_1.globalCallables) {
+            this.globalScope.symbolTable.addSymbol(callable.name, { description: callable.shortDescription }, callable.type, SymbolTable_1.SymbolTypeFlag.runtime);
+        }
+        for (const nodeData of Object.values(roku_types_1.nodes)) {
+            this.recursivelyAddNodeToSymbolTable(nodeData);
+        }
+        for (const componentData of Object.values(roku_types_1.components)) {
+            const nodeType = new types_1.InterfaceType(componentData.name);
+            nodeType.addBuiltInInterfaces();
+            if (componentData.name !== 'roSGNode') {
+                // we will add `roSGNode` as shorthand for `roSGNodeNode`, since all roSgNode components are SceneGraph nodes
+                this.globalScope.symbolTable.addSymbol(componentData.name, { description: componentData.description }, nodeType, SymbolTable_1.SymbolTypeFlag.typetime);
+            }
+        }
+        for (const ifaceData of Object.values(roku_types_1.interfaces)) {
+            const nodeType = new types_1.InterfaceType(ifaceData.name);
+            nodeType.addBuiltInInterfaces();
+            this.globalScope.symbolTable.addSymbol(ifaceData.name, { description: ifaceData.description }, nodeType, SymbolTable_1.SymbolTypeFlag.typetime);
+        }
+        for (const eventData of Object.values(roku_types_1.events)) {
+            const nodeType = new types_1.InterfaceType(eventData.name);
+            nodeType.addBuiltInInterfaces();
+            this.globalScope.symbolTable.addSymbol(eventData.name, { description: eventData.description }, nodeType, SymbolTable_1.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)
      */
@@ -99,7 +222,7 @@ class Program {
             //default to the embedded version
         }
         else {
-            return `pkg:/source/bslib.brs`;
+            return `${this.options.bslibDestinationDir}${path.sep}bslib.brs`;
         }
     }
     get bslibPrefix() {
@@ -110,18 +233,8 @@ class Program {
             return 'bslib';
         }
     }
-    /**
-     * Get a copy of the list of files currently loaded in the program
-     */
-    getAllFiles() {
-        return Object.values(this.files);
-    }
     addScope(scope) {
         this.scopes[scope.name] = scope;
-        this.plugins.emit('afterScopeCreate', {
-            program: this,
-            scope: scope
-        });
     }
     /**
      * Get the component with the specified name
@@ -130,7 +243,7 @@ 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 {
@@ -141,8 +254,7 @@ class Program {
      * 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] = [];
         }
@@ -151,8 +263,8 @@ class Program {
             scope: scope
         });
         this.components[key].sort((a, b) => {
-            const pathA = a.file.pkgPath.toLowerCase();
-            const pathB = b.file.pkgPath.toLowerCase();
+            const pathA = a.file.destPath.toLowerCase();
+            const pathB = b.file.destPath.toLowerCase();
             if (pathA < pathB) {
                 return -1;
             }
@@ -162,13 +274,13 @@ class Program {
             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) {
@@ -177,6 +289,44 @@ class Program {
             }
         }
         this.syncComponentDependencyGraph(arr);
+        this.addDeferredComponentTypeSymbolCreation(xmlFile);
+    }
+    /**
+     * Adds a component described in an XML to the set of components that needs to be updated this validation cycle.
+     * @param xmlFile XML file with <component> tag
+     */
+    addDeferredComponentTypeSymbolCreation(xmlFile) {
+        var _a;
+        this.componentSymbolsToUpdate.add({ componentKey: this.getComponentKey(xmlFile), componentName: (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text });
+    }
+    getComponentKey(xmlFile) {
+        var _a, _b;
+        return ((_b = (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : xmlFile.pkgPath).toLowerCase();
+    }
+    /**
+     * Updates the global symbol table with the first component in this.components to have the same name as the component in the file
+     * @param componentKey key getting a component from `this.components`
+     * @param componentName the unprefixed name of the component that will be added (e.g. 'MyLabel' NOT 'roSgNodeMyLabel')
+     */
+    updateComponentSymbolInGlobalScope(componentKey, componentName) {
+        const symbolName = componentName ? util_1.util.getSgNodeTypeName(componentName) : undefined;
+        if (!symbolName) {
+            return;
+        }
+        const components = this.components[componentKey] || [];
+        // Remove any existing symbols that match
+        this.globalScope.symbolTable.removeSymbol(symbolName);
+        // There is a component that can be added - use it.
+        if (components.length > 0) {
+            const componentScope = components[0].scope;
+            // TODO: May need to link symbol tables to get correct types for callfuncs
+            // componentScope.linkSymbolTable();
+            const componentType = componentScope.getComponentType();
+            if (componentType) {
+                this.globalScope.symbolTable.addSymbol(symbolName, {}, componentType, SymbolTable_1.SymbolTypeFlag.typetime);
+            }
+            // TODO: Remember to unlink! componentScope.unlinkSymbolTable();
+        }
     }
     /**
      * re-attach the dependency graph with a new key for any component who changed
@@ -190,6 +340,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);
             }
@@ -201,9 +352,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);
             }
@@ -225,13 +377,16 @@ class Program {
             //get the diagnostics from all unreferenced files
             let unreferencedFiles = this.getUnreferencedFiles();
             for (let file of unreferencedFiles) {
-                diagnostics.push(...file.getDiagnostics());
+                diagnostics.push(...file.diagnostics);
             }
             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.time(Logger_1.LogLevel.debug, ['adjust diagnostics severity'], () => {
+                this.diagnosticAdjuster.adjust(this.options, diagnostics);
+            });
             this.logger.info(`diagnostic counts: total=${chalk_1.default.yellow(diagnostics.length.toString())}, after filter=${chalk_1.default.yellow(filteredDiagnostics.length.toString())}`);
             return filteredDiagnostics;
         });
@@ -241,7 +396,7 @@ class Program {
     }
     /**
      * 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) {
@@ -249,12 +404,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];
     }
@@ -275,8 +433,14 @@ class Program {
      * Update internal maps with this file reference
      */
     assignFile(file) {
+        const fileAddEvent = {
+            file: file,
+            program: this
+        };
+        this.plugins.emit('beforeFileAdd', fileAddEvent);
         this.files[file.srcPath.toLowerCase()] = file;
-        this.pkgMap[file.pkgPath.toLowerCase()] = file;
+        this.destMap.set(file.destPath.toLowerCase(), file);
+        this.plugins.emit('afterFileAdd', fileAddEvent);
         return file;
     }
     /**
@@ -284,108 +448,155 @@ class Program {
      */
     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 = (0, util_1.standardizePath) `${this.options.rootDir}/${fileParam.substring(5)}`;
-                pkgPath = fileParam;
-                //is a srcPath (absolute path to src file location)
+    setFile(fileParam, fileData) {
+        //normalize the file paths
+        const { srcPath, destPath } = this.getPaths(fileParam, this.options.rootDir);
+        let file = this.logger.time(Logger_1.LogLevel.debug, ['Program.setFile()', chalk_1.default.green(srcPath)], () => {
+            var _a, _b, _c;
+            //if the file is already loaded, remove it
+            if (this.hasFile(srcPath)) {
+                this.removeFile(srcPath, true, true);
             }
-            else if (path.isAbsolute(fileParam)) {
-                srcPath = util_1.util.standardizePath(fileParam);
-                //assume the file path is a sub path of rootDir
-                pkgPath = util_1.util.sanitizePkgPath(roku_deploy_1.util.stringReplaceInsensitive(srcPath, this.options.rootDir, ''));
-                //is destPath (path relative to rootDir and `pkg:/`)
+            const data = new LazyFileData_1.LazyFileData(fileData);
+            const event = new ProvideFileEventInternal(this, srcPath, destPath, data, this.fileFactory);
+            this.plugins.emit('beforeProvideFile', event);
+            this.plugins.emit('provideFile', event);
+            this.plugins.emit('afterProvideFile', event);
+            //if no files were provided, create a AssetFile to represent it.
+            if (event.files.length === 0) {
+                event.files.push(this.fileFactory.AssetFile({
+                    srcPath: event.srcPath,
+                    destPath: event.destPath,
+                    pkgPath: event.destPath,
+                    data: data
+                }));
             }
-            else {
-                srcPath = (0, util_1.standardizePath) `${this.options.rootDir}/${fileParam}`;
-                pkgPath = util_1.util.sanitizePkgPath(fileParam);
+            //find the file instance for the srcPath that triggered this action.
+            const primaryFile = event.files.find(x => x.srcPath === srcPath);
+            if (!primaryFile) {
+                throw new Error(`No file provided for srcPath '${srcPath}'. Instead, received ${JSON.stringify(event.files.map(x => ({
+                    type: x.type,
+                    srcPath: x.srcPath,
+                    destPath: x.destPath
+                })))}`);
+            }
+            //link the virtual files to the primary file
+            this.fileClusters.set((_a = primaryFile.srcPath) === null || _a === void 0 ? void 0 : _a.toLowerCase(), event.files);
+            for (const file of event.files) {
+                file.srcPath = (0, util_1.standardizePath)(file.srcPath);
+                if (file.destPath) {
+                    file.destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(file.destPath, this.options.rootDir, '')}`;
+                }
+                if (file.pkgPath) {
+                    file.pkgPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(file.pkgPath, this.options.rootDir, '')}`;
+                }
+                else {
+                    file.pkgPath = file.destPath;
+                }
+                file.excludeFromOutput = file.excludeFromOutput === true;
+                //set the dependencyGraph key for every file to its destPath
+                file.dependencyGraphKey = file.destPath.toLowerCase();
+                this.assignFile(file);
+                //register a callback anytime this file's dependencies change
+                if (typeof file.onDependenciesChanged === 'function') {
+                    (_b = file.disposables) !== null && _b !== void 0 ? _b : (file.disposables = []);
+                    file.disposables.push(this.dependencyGraph.onchange(file.dependencyGraphKey, file.onDependenciesChanged.bind(file)));
+                }
+                //register this file (and its dependencies) with the dependency graph
+                this.dependencyGraph.addOrReplace(file.dependencyGraphKey, (_c = file.dependencies) !== null && _c !== void 0 ? _c : []);
+                //if this is a `source` file, add it to the source scope's dependency list
+                if (this.isSourceBrsFile(file)) {
+                    this.createSourceScope();
+                    this.dependencyGraph.addDependency('scope:source', file.dependencyGraphKey);
+                }
+                //if this is an xml file in the components folder, register it as a component
+                if (this.isComponentsXmlFile(file)) {
+                    //create a new scope for this xml file
+                    let scope = new XmlScope_1.XmlScope(file, this);
+                    this.addScope(scope);
+                    //register this compoent now that we have parsed it and know its component name
+                    this.registerComponent(file, scope);
+                    //notify plugins that the scope is created and the component is registered
+                    this.plugins.emit('afterScopeCreate', {
+                        program: this,
+                        scope: scope
+                    });
+                }
             }
-            //is a FileObj
+            return primaryFile;
+        });
+        return file;
+    }
+    /**
+     * Given a srcPath, a destPath, or both, resolve whichever is missing, relative to rootDir.
+     * @param fileParam an object representing file paths
+     * @param rootDir must be a pre-normalized path
+     */
+    getPaths(fileParam, rootDir) {
+        let srcPath;
+        let destPath;
+        assert.ok(fileParam, 'fileParam is required');
+        //lift the path vars from the incoming param
+        if (typeof fileParam === 'string') {
+            fileParam = this.removePkgPrefix(fileParam);
+            srcPath = (0, util_1.standardizePath) `${path.resolve(rootDir, fileParam)}`;
+            destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
         }
         else {
-            srcPath = (0, 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.setFile()', chalk_1.default.green(srcPath)], () => {
-            assert.ok(srcPath, 'srcPath is required');
-            assert.ok(pkgPath, 'pkgPath is required');
-            //if the file is already loaded, remove it
-            if (this.hasFile(srcPath)) {
-                this.removeFile(srcPath);
+            let param = fileParam;
+            if (param.src) {
+                srcPath = (0, util_1.standardizePath) `${param.src}`;
             }
-            let fileExtension = path.extname(srcPath).toLowerCase();
-            let file;
-            const beforeFileParseEvent = {
-                program: this,
-                srcPath: srcPath,
-                source: fileContents
-            };
-            if (fileExtension === '.brs' || fileExtension === '.bs') {
-                //add the file to the program
-                const brsFile = this.assignFile(new BrsFile_1.BrsFile(srcPath, pkgPath, this));
-                //add file to the `source` dependency list
-                if (brsFile.pkgPath.startsWith('pkg:/source/')) {
-                    this.createSourceScope();
-                    this.dependencyGraph.addDependency('scope:source', brsFile.dependencyGraphKey);
-                }
-                //add the file to the program
-                this.assignFile(brsFile);
-                this.plugins.emit('beforeFileParse', beforeFileParseEvent);
-                this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
-                    brsFile.parse(beforeFileParseEvent.source);
-                });
-                //notify plugins that this file has finished parsing
-                this.plugins.emit('afterFileParse', {
-                    program: this,
-                    file: brsFile
-                });
-                file = brsFile;
-                brsFile.attachDependencyGraph(this.dependencyGraph);
+            if (param.srcPath) {
+                srcPath = (0, util_1.standardizePath) `${param.srcPath}`;
             }
-            else if (
-            //is xml file
-            fileExtension === '.xml' &&
-                //resides in the components folder (Roku will only parse xml files in the components folder)
-                lowerPkgPath.startsWith('pkg:/components/')) {
-                //add the file to the program
-                const xmlFile = this.assignFile(new XmlFile_1.XmlFile(srcPath, pkgPath, this));
-                this.plugins.emit('beforeFileParse', beforeFileParseEvent);
-                this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
-                    xmlFile.parse(beforeFileParseEvent.source);
-                });
-                //notify plugins that this file has finished parsing
-                this.plugins.emit('afterFileParse', {
-                    program: this,
-                    file: xmlFile
-                });
-                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);
+            if (param.dest) {
+                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.dest)}`;
             }
-            else {
-                //TODO do we actually need to implement this? Figure out how to handle img paths
-                // let genericFile = this.files[srcPath] = <any>{
-                //     srcPath: srcPath,
-                //     pkgPath: pkgPath,
-                //     wasProcessed: true
-                // } as File;
-                // file = <any>genericFile;
+            if (param.pkgPath) {
+                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.pkgPath)}`;
             }
-            return file;
-        });
+        }
+        //if there's no srcPath, use the destPath to build an absolute srcPath
+        if (!srcPath) {
+            srcPath = (0, util_1.standardizePath) `${rootDir}/${destPath}`;
+        }
+        //coerce srcPath to an absolute path
+        if (!path.isAbsolute(srcPath)) {
+            srcPath = util_1.util.standardizePath(srcPath);
+        }
+        //if destPath isn't set, compute it from the other paths
+        if (!destPath) {
+            destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
+        }
+        assert.ok(srcPath, 'fileEntry.src is required');
+        assert.ok(destPath, 'fileEntry.dest is required');
+        return {
+            srcPath: srcPath,
+            //remove leading slash
+            destPath: destPath.replace(/^[\/\\]+/, '')
+        };
+    }
+    /**
+     * Remove any leading `pkg:/` found in the path
+     */
+    removePkgPrefix(path) {
+        return path.replace(/^pkg:\//i, '');
+    }
+    /**
+     * Is this file a .brs file found somewhere within the `pkg:/source/` folder?
+     */
+    isSourceBrsFile(file) {
+        return !!/^(pkg:\/)?source[\/\\]/.exec(file.destPath);
+    }
+    /**
+     * Is this file a .brs file found somewhere within the `pkg:/source/` folder?
+     */
+    isComponentsXmlFile(file) {
+        return (0, reflection_1.isXmlFile)(file) && !!/^(pkg:\/)?components[\/\\]/.exec(file.destPath);
     }
     /**
      * Ensure source scope is created.
@@ -396,11 +607,15 @@ class Program {
             const sourceScope = new Scope_1.Scope('source', this, 'scope:source');
             sourceScope.attachDependencyGraph(this.dependencyGraph);
             this.addScope(sourceScope);
+            this.plugins.emit('afterScopeCreate', {
+                program: this,
+                scope: sourceScope
+            });
         }
     }
     /**
      * Remove a set of files from the program
-     * @param filePaths can be an array of srcPath or destPath strings
+     * @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, normalizePath = true) {
@@ -410,69 +625,58 @@ class Program {
     }
     /**
      * 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;
+            }
+            const event = { file: file, program: this };
+            this.plugins.emit('beforeFileRemove', event);
             //if there is a scope named the same as this file's path, remove it (i.e. xml scopes)
-            let scope = this.scopes[file.pkgPath];
+            let scope = this.scopes[file.destPath];
             if (scope) {
-                this.plugins.emit('beforeScopeDispose', {
+                const scopeDisposeEvent = {
                     program: this,
                     scope: scope
-                });
+                };
+                this.plugins.emit('beforeScopeDispose', scopeDisposeEvent);
+                this.plugins.emit('onScopeDispose', scopeDisposeEvent);
                 scope.dispose();
                 //notify dependencies of this scope that it has been removed
                 this.dependencyGraph.remove(scope.dependencyGraphKey);
-                delete this.scopes[file.pkgPath];
-                this.plugins.emit('afterScopeDispose', {
-                    program: this,
-                    scope: scope
-                });
+                delete this.scopes[file.destPath];
+                this.plugins.emit('afterScopeDispose', scopeDisposeEvent);
             }
             //remove the file from the program
             this.unassignFile(file);
             this.dependencyGraph.remove(file.dependencyGraphKey);
             //if this is a pkg:/source file, notify the `source` scope that it has changed
-            if (file.pkgPath.startsWith('pkg:/source/')) {
+            if (this.isSourceBrsFile(file)) {
                 this.dependencyGraph.removeDependency('scope:source', file.dependencyGraphKey);
+                if (!keepSymbolInformation) {
+                    this.fileSymbolInformation.delete(file.pkgPath);
+                }
             }
             //if this is a component, remove it from our components map
             if ((0, reflection_1.isXmlFile)(file)) {
                 this.unregisterComponent(file);
             }
-            //dispose file
-            file === null || file === void 0 ? void 0 : file.dispose();
-            this.plugins.emit('afterFileDispose', {
-                program: this,
-                file: file
-            });
-        }
-    }
-    /**
-     * Remove all files from the program that are in the specified folder path (recursive)
-     * @param folderSrcPath The absolute path to the folder on disk
-     * @param normalizePath should the provided path be normalized before use?
-     */
-    removeFilesInFolder(folderSrcPath, normalizePath = true) {
-        if (normalizePath) {
-            folderSrcPath = util_1.util.standardizePath(folderSrcPath);
-        }
-        const lowerFolderSrcPath = folderSrcPath.toLowerCase();
-        for (const key in this.files) {
-            const file = this.files[key];
-            const lowerSrcPath = file.srcPath.toLowerCase();
-            //if the file path starts with the parent path and the file path does not exactly match the folder path
-            if (lowerSrcPath.toLowerCase().startsWith(lowerFolderSrcPath) && lowerSrcPath !== lowerFolderSrcPath) {
-                this.removeFile(file.srcPath, false);
+            //dispose any disposable things on the file
+            for (const disposable of (_c = file === null || file === void 0 ? void 0 : file.disposables) !== null && _c !== void 0 ? _c : []) {
+                disposable();
             }
+            //dispose file
+            (_d = file === null || file === void 0 ? void 0 : file.dispose) === null || _d === void 0 ? void 0 : _d.call(file);
+            this.plugins.emit('afterFileRemove', event);
         }
     }
     /**
@@ -480,78 +684,157 @@ class Program {
      */
     validate() {
         this.logger.time(Logger_1.LogLevel.log, ['Validating project'], () => {
-            var _a;
+            var _a, _b, _c, _d, _e, _f, _g;
             this.diagnostics = [];
-            this.plugins.emit('beforeProgramValidate', {
+            const programValidateEvent = {
                 program: this
-            });
+            };
+            this.plugins.emit('beforeProgramValidate', programValidateEvent);
+            this.plugins.emit('onProgramValidate', programValidateEvent);
             //validate every file
+            const brsFilesValidated = [];
             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) }));
-                }
                 //for every unvalidated file, validate it
                 if (!file.isValidated) {
-                    this.plugins.emit('beforeFileValidate', {
+                    const validateFileEvent = {
                         program: this,
                         file: file
-                    });
+                    };
+                    this.plugins.emit('beforeFileValidate', validateFileEvent);
                     //emit an event to allow plugins to contribute to the file validation process
-                    this.plugins.emit('onFileValidate', {
-                        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);
+                    this.plugins.emit('onFileValidate', validateFileEvent);
                     file.isValidated = true;
-                    this.plugins.emit('afterFileValidate', {
-                        program: this,
-                        file: file
-                    });
+                    if ((0, reflection_1.isBrsFile)(file)) {
+                        brsFilesValidated.push(file);
+                    }
+                    this.plugins.emit('afterFileValidate', validateFileEvent);
                 }
             }
-            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) {
-                        scope.linkSymbolTable();
-                        scope.validate();
-                        scope.unlinkSymbolTable();
-                        scope.isValidated = true;
+            // build list of all changed symbols in each file that changed
+            this.lastValidationInfo.clear();
+            for (const file of brsFilesValidated) {
+                const fileInfo = {
+                    symbolsNotDefinedInEveryScope: [],
+                    duplicateSymbolsInSameScope: [],
+                    symbolsNotConsistentAcrossScopes: []
+                };
+                const scopesToCheckForConsistency = this.getScopesForFile(file);
+                for (const symbol of file.requiredSymbols) {
+                    let providedSymbolType;
+                    let scopesDefiningSymbol = [];
+                    let scopesAreInconsistent = false;
+                    for (const scope of scopesToCheckForConsistency) {
+                        let symbolFoundInScope = false;
+                        for (const scopeFile of scope.getAllFiles()) {
+                            if (!(0, reflection_1.isBrsFile)(scopeFile) || scopeFile.isTypedef || scopeFile.hasTypedef) {
+                                continue;
+                            }
+                            const lowerFirstSymbolName = (_b = (_a = symbol.typeChain) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.name.toLowerCase();
+                            let symbolInThisScope = (_d = (_c = scopeFile.providedSymbols.symbolMap) === null || _c === void 0 ? void 0 : _c.get(symbol.flags)) === null || _d === void 0 ? void 0 : _d.get(lowerFirstSymbolName);
+                            if (!symbolInThisScope && ((_e = symbol.containingNamespaces) === null || _e === void 0 ? void 0 : _e.length) > 0) {
+                                const fullNameWithNamespaces = (symbol.containingNamespaces.join('.') + '.' + lowerFirstSymbolName).toLowerCase();
+                                symbolInThisScope = (_g = (_f = scopeFile.providedSymbols.symbolMap) === null || _f === void 0 ? void 0 : _f.get(symbol.flags)) === null || _g === void 0 ? void 0 : _g.get(fullNameWithNamespaces);
+                            }
+                            if (symbolInThisScope) {
+                                if (symbolFoundInScope) {
+                                    // this is duplicately defined!
+                                    fileInfo.duplicateSymbolsInSameScope.push({ symbol: symbol, scope: scope });
+                                }
+                                else {
+                                    symbolFoundInScope = true;
+                                    scopesDefiningSymbol.push(scope);
+                                    //check for consistency across scopes
+                                    if (!providedSymbolType) {
+                                        providedSymbolType = symbolInThisScope.type;
+                                    }
+                                    else {
+                                        //get more general type
+                                        if (providedSymbolType.isEqual(symbolInThisScope.type)) {
+                                            //type in this scope is the same as one we're already checking
+                                        }
+                                        else if (providedSymbolType.isTypeCompatible(symbolInThisScope.type)) {
+                                            //type in this scope is compatible with one we're storing. use most generic
+                                            providedSymbolType = symbolInThisScope.type;
+                                        }
+                                        else if (symbolInThisScope.type.isTypeCompatible(providedSymbolType)) {
+                                            // type we're storing is more generic that the type in this scope
+                                        }
+                                        else {
+                                            // type in this scope is not compatible with other types for this symbol
+                                            scopesAreInconsistent = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if (!symbolFoundInScope) {
+                            fileInfo.symbolsNotDefinedInEveryScope.push({ symbol: symbol, scope: scope });
+                        }
+                    }
+                    if (scopesAreInconsistent) {
+                        fileInfo.symbolsNotConsistentAcrossScopes.push({ symbol: symbol, scopes: scopesDefiningSymbol });
                     }
                 }
+                this.lastValidationInfo.set(file.srcPath.toLowerCase(), fileInfo);
+            }
+            this.detectIncompatibleSymbolsAcrossScopes();
+            // Build component types for any component that changes
+            this.logger.time(Logger_1.LogLevel.info, ['Build component types'], () => {
+                for (let { componentKey, componentName } of this.componentSymbolsToUpdate) {
+                    this.updateComponentSymbolInGlobalScope(componentKey, componentName);
+                }
+                this.componentSymbolsToUpdate.clear();
             });
-            this.detectDuplicateComponentNames();
-            this.plugins.emit('afterProgramValidate', {
-                program: this
+            const changedSymbolsMapArr = brsFilesValidated === null || brsFilesValidated === void 0 ? void 0 : brsFilesValidated.map(f => {
+                if ((0, reflection_1.isBrsFile)(f)) {
+                    return f.providedSymbols.changes;
+                }
+                return null;
+            }).filter(x => x);
+            const changedSymbols = new Map();
+            for (const flag of [SymbolTable_1.SymbolTypeFlag.runtime, SymbolTable_1.SymbolTypeFlag.typetime]) {
+                const changedSymbolsSetArr = changedSymbolsMapArr.map(symMap => symMap.get(flag));
+                changedSymbols.set(flag, new Set(...changedSymbolsSetArr));
+            }
+            this.logger.time(Logger_1.LogLevel.info, ['Validate all scopes'], () => {
+                for (let scopeName in this.scopes) {
+                    let scope = this.scopes[scopeName];
+                    scope.validate({ changedFiles: brsFilesValidated, changedSymbols: changedSymbols });
+                }
             });
+            this.detectDuplicateComponentNames();
+            this.plugins.emit('afterProgramValidate', programValidateEvent);
         });
     }
+    detectIncompatibleSymbolsAcrossScopes() {
+        for (const [lowerFilePath, fileInfo] of this.lastValidationInfo.entries()) {
+            const file = this.files[lowerFilePath];
+            for (const symbolAndScopes of fileInfo.symbolsNotConsistentAcrossScopes) {
+                const typeChainResult = util_1.util.processTypeChain(symbolAndScopes.symbol.typeChain);
+                const scopeListName = symbolAndScopes.scopes.map(s => s.name).join(', ');
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.incompatibleSymbolDefinition(typeChainResult.fullNameOfItem, scopeListName)), { file: file, range: typeChainResult.range }));
+            }
+        }
+    }
     /**
      * 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 ((0, 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) {
@@ -567,17 +850,6 @@ class Program {
             }
         }
     }
-    /**
-     * Determine at least one scope has the file
-     */
-    fileIsIncludedInAnyScope(file) {
-        for (let scope of Object.values(this.scopes)) {
-            if (scope.hasFile(file)) {
-                return true;
-            }
-        }
-        return false;
-    }
     /**
      * Get the files for a list of filePaths
      * @param filePaths can be an array of srcPath or a destPath strings
@@ -590,33 +862,32 @@ class Program {
     }
     /**
      * Get the file at the given path
-     * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
+     * @param filePath can be a srcPath or a destPath
      * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
      */
     getFile(filePath, normalizePath = true) {
         if (typeof filePath !== 'string') {
             return undefined;
+            //is the path absolute (or the `virtual:` prefix)
         }
-        else if (path.isAbsolute(filePath)) {
+        else if (/^(?:(?:virtual:[\/\\])|(?:\w:)|(?:[\/\\]))/gmi.exec(filePath)) {
             return this.files[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
         }
         else {
-            return this.pkgMap[(normalizePath ? util_1.util.sanitizePkgPath(filePath) : filePath).toLowerCase()];
+            return this.destMap.get((normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase());
         }
     }
     /**
      * Get a list of all scopes the file is loaded into
-     * @param file
+     * @param file the file
      */
     getScopesForFile(file) {
-        if (typeof file === 'string') {
-            file = this.getFile(file);
-        }
+        const resolvedFile = typeof file === 'string' ? this.getFile(file) : file;
         let result = [];
-        if (file) {
+        if (resolvedFile) {
             for (let key in this.scopes) {
                 let scope = this.scopes[key];
-                if (scope.hasFile(file)) {
+                if (scope.hasFile(resolvedFile)) {
                     result.push(scope);
                 }
             }
@@ -635,26 +906,37 @@ class Program {
         }
     }
     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.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 ((0, 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()];
@@ -667,40 +949,41 @@ class Program {
         let funcNames = new Set();
         let currentScope = scope;
         while ((0, 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 ((0, reflection_1.isSGInterfaceFunction)(member)) {
-                    const name = member.name;
-                    if (!filterName || name === filterName) {
-                        funcNames.add(name);
-                    }
+            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 ((0, 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.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 [];
         }
@@ -724,19 +1007,18 @@ class Program {
      * 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 results = Object.keys(this.files).map(key => {
             const file = this.files[key];
             if ((0, reflection_1.isBrsFile)(file)) {
-                result.push(...file.getWorkspaceSymbols());
+                return file.getWorkspaceSymbols();
             }
-        }
-        return result;
+            return [];
+        });
+        return util_1.util.flatMap(results, c => c);
     }
     /**
      * 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);
@@ -757,7 +1039,6 @@ class Program {
     }
     /**
      * Get hover information for a file and position
-     * @param srcPath The absolute path to the source file on disk
      */
     getHover(srcPath, position) {
         let file = this.getFile(srcPath);
@@ -779,7 +1060,6 @@ class Program {
     }
     /**
      * 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 = [];
@@ -821,277 +1101,23 @@ class Program {
         }
     }
     getSignatureHelp(filepath, position) {
-        var _a;
         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) {
-                const currentToken = file.parser.getTokenAt(position);
-                for (let scope of this.getScopesForFile(file)) {
-                    scope.linkSymbolTable();
-                    let myClass = file.getClassFromToken(currentToken, functionExpression, scope);
-                    if (myClass) {
-                        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) => (0, reflection_1.isMethodStatement)(i.item))) {
-                            let sigHelp = statement.file.getSignatureHelpForStatement(statement.item);
-                            if (sigHelp && !results.has[sigHelp.key]) {
-                                results.set(sigHelp.key, sigHelp);
-                                return;
-                            }
-                        }
-                    }
-                    scope.unlinkSymbolTable();
-                }
-            }
-            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) => (0, 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()];
-    }
-    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 !== TokenKind_1.TokenKind.Comment) {
-                name = file.getPartialVariableName(currentToken, [TokenKind_1.TokenKind.New]);
-                if (!name) {
-                    //try the previous token, incase we're on a bracket
-                    currentToken = file.parser.getPreviousToken(currentToken);
-                    name = file.getPartialVariableName(currentToken, [TokenKind_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);
-                    }
-                }
-                break;
-            }
-            if (line.substr(index - 2, 2) === '@.') {
-                statementType = '@.';
-                name = name || line.substring(index, argStartIndex);
-                break;
-            }
-            else if (line.charAt(index - 1) === '.' && statementType === '') {
-                statementType = '.';
-                name = name || line.substring(index, argStartIndex);
-                argStartIndex = index;
-            }
-            index--;
-        }
-        if (line.substring(0, index).trim().endsWith('new')) {
-            statementType = 'new';
-        }
-        return {
-            commaCount: itemCounts.comma,
-            statementType: statementType,
-            name: name,
-            dotPart: dotPart
-        };
-    }
-    getPartialItemCounts(line, index) {
-        let isArgStartFound = false;
-        let itemCounts = {
-            normal: 0,
-            square: 0,
-            curly: 0,
-            comma: 0,
-            endIndex: 0,
-            argStartIndex: index,
-            isArgStartFound: false
-        };
-        while (index >= 0) {
-            const currentChar = line.charAt(index);
-            if (currentChar === '\'') { //found comment, invalid index
-                itemCounts.isArgStartFound = false;
-                break;
-            }
-            if (isArgStartFound) {
-                if (currentChar !== ' ') {
-                    break;
-                }
-            }
-            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--;
-                }
-            }
-            index--;
-        }
-        return itemCounts;
+        let callExpressionInfo = new CallExpressionInfo_1.CallExpressionInfo(file, position);
+        let signatureHelpUtil = new SignatureHelpUtil_1.SignatureHelpUtil();
+        return signatureHelpUtil.getSignatureHelpItems(callExpressionInfo);
     }
-    /**
-     * @param srcPath The absolute path to the source file on disk
-     */
     getReferences(srcPath, position) {
         //find the file
         let file = this.getFile(srcPath);
-        if (!file) {
-            return null;
+        if ((0, reflection_1.isBrsFile)(file) || (0, reflection_1.isXmlFile)(file)) {
+            return file.getReferences(position);
         }
-        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
-                        }
-                    });
-                }
-            }
+        else {
+            return null;
         }
-        return result;
     }
     /**
      * Transpile a single file and get the result as a string.
@@ -1102,160 +1128,215 @@ class Program {
      * @param filePath can be a srcPath or a destPath
      */
     async getTranspiledFileContents(filePath) {
-        const { entries, astEditor } = this.beforeProgramTranspile(await roku_deploy_1.rokuDeploy.getFilePaths(this.options.files, this.options.rootDir), this.options.stagingFolderPath);
-        const result = this._getTranspiledFileContents(this.getFile(filePath));
-        this.afterProgramTranspile(entries, astEditor);
+        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);
+                }
+            });
+            try {
+                //now that the plugin has been registered, run the build with just this file
+                await this.build({
+                    files: [file]
+                });
+            }
+            finally {
+                this.plugins.remove(plugin);
+            }
+            return result;
+        });
+    }
+    /**
+     * Get the absolute output path for a file
+     */
+    getOutputPath(file, stagingDir = this.getStagingDir()) {
+        return (0, util_1.standardizePath) `${stagingDir}/${file.pkgPath}`;
+    }
+    getStagingDir(stagingDir) {
+        var _a, _b;
+        let result = (_a = stagingDir !== null && stagingDir !== void 0 ? stagingDir : this.options.stagingDir) !== null && _a !== void 0 ? _a : this.options.stagingDir;
+        if (!result) {
+            result = roku_deploy_1.rokuDeploy.getOptions(this.options).stagingDir;
+        }
+        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;
     }
     /**
-     * Internal function used to transpile files.
-     * This does not write anything to the file system
+     * Prepare the program for building
+     * @param files the list of files that should be prepared
      */
-    _getTranspiledFileContents(file, outputPath) {
-        const editor = new AstEditor_1.AstEditor();
-        this.plugins.emit('beforeFileTranspile', {
+    async prepare(files) {
+        const programEvent = {
             program: this,
-            file: file,
-            outputPath: outputPath,
-            editor: editor
+            editor: this.editor,
+            files: files
+        };
+        //assign an editor to every file
+        for (const file of files) {
+            //if the file doesn't have an editor yet, assign one now
+            if (!file.editor) {
+                file.editor = new Editor_1.Editor();
+            }
+        }
+        files.sort((a, b) => {
+            if (a.pkgPath < b.pkgPath) {
+                return -1;
+            }
+            else if (a.pkgPath > b.pkgPath) {
+                return 1;
+            }
+            else {
+                return 1;
+            }
         });
-        //if we have any edits, assume the file needs to be transpiled
-        if (editor.hasChanges) {
-            //use the `editor` because it'll track the previous value for us and revert later on
-            editor.setProperty(file, 'needsTranspiled', true);
-        }
-        //transpile the file
-        const result = file.transpile();
-        //generate the typedef if enabled
-        let typedef;
-        if ((0, reflection_1.isBrsFile)(file) && this.options.emitDefinitions) {
-            typedef = file.getTypedef();
+        await this.plugins.emitAsync('beforePrepareProgram', programEvent);
+        await this.plugins.emitAsync('prepareProgram', programEvent);
+        const stagingDir = this.getStagingDir();
+        const entries = [];
+        for (const file of files) {
+            //if the file doesn't have an editor yet, assign one now
+            if (!file.editor) {
+                file.editor = new Editor_1.Editor();
+            }
+            const event = {
+                program: this,
+                file: file,
+                editor: file.editor,
+                outputPath: this.getOutputPath(file, stagingDir)
+            };
+            await this.plugins.emitAsync('beforePrepareFile', event);
+            await this.plugins.emitAsync('prepareFile', event);
+            await this.plugins.emitAsync('afterPrepareFile', event);
+            //TODO remove this in v1
+            entries.push(event);
         }
-        const event = {
-            program: this,
-            file: file,
-            outputPath: outputPath,
-            editor: editor,
-            code: result.code,
-            map: result.map,
-            typedef: typedef
-        };
-        this.plugins.emit('afterFileTranspile', event);
-        //undo all `editor` edits that may have been applied to this file.
-        editor.undoAll();
-        return {
-            srcPath: file.srcPath,
-            pkgPath: file.pkgPath,
-            code: event.code,
-            map: event.map,
-            typedef: event.typedef
-        };
+        await this.plugins.emitAsync('afterPrepareProgram', programEvent);
+        return files;
     }
-    beforeProgramTranspile(fileEntries, stagingFolderPath) {
-        // map fileEntries using their path as key, to avoid excessive "find()" operations
-        const mappedFileEntries = fileEntries.reduce((collection, entry) => {
-            collection[(0, util_1.standardizePath) `${entry.src}`] = entry;
-            return collection;
-        }, {});
-        const getOutputPath = (file) => {
-            let filePathObj = mappedFileEntries[(0, 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 = (0, util_1.standardizePath) `${stagingFolderPath}/${outputPath}`;
-            return outputPath;
-        };
-        const entries = Object.values(this.files).map(file => {
-            return {
+    /**
+     * Generate the contents of every file
+     */
+    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);
+        }
+        const serializeProgramEvent = await this.plugins.emitAsync('beforeSerializeProgram', {
+            program: this,
+            files: files,
+            result: allFiles
+        });
+        await this.plugins.emitAsync('onSerializeProgram', {
+            program: this,
+            files: files,
+            result: allFiles
+        });
+        //sort the entries to make transpiling more deterministic
+        files = serializeProgramEvent.files.sort((a, b) => {
+            return a.srcPath < b.srcPath ? -1 : 1;
+        });
+        // serialize each file
+        for (const file of files) {
+            const event = {
+                program: this,
                 file: file,
-                outputPath: getOutputPath(file)
+                result: allFiles
             };
+            await this.plugins.emitAsync('beforeSerializeFile', event);
+            await this.plugins.emitAsync('serializeFile', event);
+            await this.plugins.emitAsync('afterSerializeFile', event);
+        }
+        this.plugins.emit('afterSerializeProgram', {
+            program: this,
+            files: files,
+            result: allFiles
         });
-        const astEditor = new AstEditor_1.AstEditor();
-        this.plugins.emit('beforeProgramTranspile', {
+        return allFiles;
+    }
+    /**
+     * Write the entire project to disk
+     */
+    async write(stagingDir, files) {
+        const programEvent = await this.plugins.emitAsync('beforeWriteProgram', {
             program: this,
-            entries: entries,
-            editor: astEditor
+            files: files,
+            stagingDir: stagingDir
         });
-        return {
-            entries: entries,
-            getOutputPath: getOutputPath,
-            astEditor: astEditor
-        };
+        //empty the staging directory
+        await fsExtra.emptyDir(stagingDir);
+        const serializedFiles = [...files]
+            .map(([, serializedFiles]) => serializedFiles)
+            .flat();
+        //write all the files to disk (asynchronously)
+        await Promise.all(serializedFiles.map(async (file) => {
+            const event = await this.plugins.emitAsync('beforeWriteFile', {
+                program: this,
+                file: file,
+                outputPath: this.getOutputPath(file, stagingDir),
+                processedFiles: new Set()
+            });
+            await this.plugins.emitAsync('writeFile', event);
+            await this.plugins.emitAsync('afterWriteFile', event);
+        }));
+        await this.plugins.emitAsync('afterWriteProgram', programEvent);
     }
-    async transpile(fileEntries, stagingFolderPath) {
-        const { entries, getOutputPath, astEditor } = this.beforeProgramTranspile(fileEntries, stagingFolderPath);
-        const processedFiles = new Set();
-        const transpileFile = async (srcPath, outputPath) => {
-            //find the file in the program
-            const file = this.getFile(srcPath);
-            //mark this file as processed so we don't process it more than once
-            processedFiles.add(file);
-            //skip transpiling typedef files
-            if ((0, reflection_1.isBrsFile)(file) && file.isTypedef) {
-                return;
-            }
-            const fileTranspileResult = this._getTranspiledFileContents(file, outputPath);
-            //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 = fileTranspileResult.map ? fsExtra.writeFile(`${outputPath}.map`, fileTranspileResult.map.toString()) : null;
-            await Promise.all([
-                fsExtra.writeFile(outputPath, fileTranspileResult.code),
-                writeMapPromise
-            ]);
-            if (fileTranspileResult.typedef) {
-                const typedefPath = outputPath.replace(/\.brs$/i, '.d.bs');
-                await fsExtra.writeFile(typedefPath, fileTranspileResult.typedef);
-            }
-        };
-        let promises = entries.map(async (entry) => {
+    /**
+     * 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;
-            return transpileFile((_a = entry === null || entry === void 0 ? void 0 : entry.file) === null || _a === void 0 ? void 0 : _a.srcPath, entry.outputPath);
-        });
-        //if there's no bslib file already loaded into the program, copy it to the staging directory
-        if (!this.getFile(bslibAliasedRokuModulesPkgPath) && !this.getFile((0, util_1.standardizePath) `pkg:/source/bslib.brs`)) {
-            promises.push(util_1.util.copyBslibToStaging(stagingFolderPath));
-        }
-        await Promise.all(promises);
-        //transpile any new files that plugins added since the start of this transpile process
-        do {
-            promises = [];
-            for (const key in this.files) {
-                const file = this.files[key];
-                //this is a new file
-                if (!processedFiles.has(file)) {
-                    promises.push(transpileFile(file === null || file === void 0 ? void 0 : file.srcPath, getOutputPath(file)));
-                }
-            }
-            if (promises.length > 0) {
-                this.logger.info(`Transpiling ${promises.length} new files`);
-                await Promise.all(promises);
+            const stagingDir = this.getStagingDir(options === null || options === void 0 ? void 0 : options.stagingDir);
+            const event = await this.plugins.emitAsync('beforeBuildProgram', {
+                program: this,
+                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(stagingDir, serializedFilesByFile);
+            await this.plugins.emitAsync('afterBuildProgram', event);
+            //undo all edits for the program
+            this.editor.undoAll();
+            //undo all edits for each file
+            for (const file of event.files) {
+                file.editor.undoAll();
             }
-        } while (promises.length > 0);
-        this.afterProgramTranspile(entries, astEditor);
-    }
-    afterProgramTranspile(entries, astEditor) {
-        this.plugins.emit('afterProgramTranspile', {
-            program: this,
-            entries: entries,
-            editor: astEditor
         });
-        astEditor.undoAll();
     }
     /**
      * Find a list of files in the program that have a function with the given name (case INsensitive)
@@ -1268,7 +1349,8 @@ class Program {
             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);
                 }
             }
@@ -1286,7 +1368,8 @@ class Program {
             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);
                 }
             }
@@ -1299,7 +1382,8 @@ class Program {
         //find every file with this class defined
         for (const file of Object.values(this.files)) {
             if ((0, reflection_1.isBrsFile)(file)) {
-                if (file.parser.references.namespaceStatements.find((x) => {
+                // 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
@@ -1316,48 +1400,100 @@ class Program {
     findFilesForEnum(name) {
         const files = [];
         const lowerName = name.toLowerCase();
-        //find every file with this class defined
+        //find every file with this enum defined
         for (const file of Object.values(this.files)) {
             if ((0, reflection_1.isBrsFile)(file)) {
-                if (file.parser.references.enumStatementLookup.get(lowerName)) {
+                // 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 = (0, Manifest_1.parseManifest)(contents);
-            }
-            catch (err) {
-                this._manifest = new Map();
-            }
+            this.loadManifest();
         }
         return this._manifest;
     }
     dispose() {
-        var _a, _b;
-        for (const key in this.files) {
-            const file = this.files[key];
-            (_a = file.dispose) === null || _a === void 0 ? void 0 : _a.call(file);
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        this.plugins.emit('beforeProgramDispose', { program: this });
+        for (let filePath in this.files) {
+            (_b = (_a = this.files[filePath]) === null || _a === void 0 ? void 0 : _a.dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
         }
         for (let name in this.scopes) {
-            (_b = this.scopes[name]) === null || _b === void 0 ? void 0 : _b.dispose();
+            (_d = (_c = this.scopes[name]) === null || _c === void 0 ? void 0 : _c.dispose) === null || _d === void 0 ? void 0 : _d.call(_c);
         }
-        this.globalScope.dispose();
-        this.dependencyGraph.dispose();
+        (_f = (_e = this.globalScope) === null || _e === void 0 ? void 0 : _e.dispose) === null || _f === void 0 ? void 0 : _f.call(_e);
+        (_h = (_g = this.dependencyGraph) === null || _g === void 0 ? void 0 : _g.dispose) === null || _h === void 0 ? void 0 : _h.call(_g);
     }
 }
 exports.Program = Program;
+class ProvideFileEventInternal {
+    constructor(program, srcPath, destPath, data, fileFactory) {
+        var _a;
+        this.program = program;
+        this.srcPath = srcPath;
+        this.destPath = destPath;
+        this.data = data;
+        this.fileFactory = fileFactory;
+        this.files = [];
+        this.srcExtension = (_a = path.extname(srcPath)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    }
+}
 //# sourceMappingURL=Program.js.map