brighterscript 0.66.0-alpha.8 → 0.67.0

package/dist/Program.js

@@ -4,13 +4,16 @@ exports.Program = void 0;
 const assert = require("assert");
 const fsExtra = require("fs-extra");
 const path = require("path");
+const vscode_languageserver_1 = require("vscode-languageserver");
 const Scope_1 = require("./Scope");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
+const BrsFile_1 = require("./files/BrsFile");
+const XmlFile_1 = require("./files/XmlFile");
 const util_1 = require("./util");
 const XmlScope_1 = require("./XmlScope");
 const DiagnosticFilterer_1 = require("./DiagnosticFilterer");
 const DependencyGraph_1 = require("./DependencyGraph");
-const Logger_1 = require("./Logger");
+const logging_1 = require("./logging");
 const chalk_1 = require("chalk");
 const globalCallables_1 = require("./globalCallables");
 const Manifest_1 = require("./preprocessor/Manifest");
@@ -18,29 +21,12 @@ const vscode_uri_1 = require("vscode-uri");
 const PluginInterface_1 = require("./PluginInterface");
 const reflection_1 = require("./astUtils/reflection");
 const BscPlugin_1 = require("./bscPlugin/BscPlugin");
-const Editor_1 = require("./astUtils/Editor");
+const AstEditor_1 = require("./astUtils/AstEditor");
+const roku_deploy_1 = require("roku-deploy");
 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 roku_types_1 = require("./roku-types");
-const ComponentType_1 = require("./types/ComponentType");
-const types_1 = require("./types");
-const BuiltInInterfaceAdder_1 = require("./types/BuiltInInterfaceAdder");
+const startOfSourcePkgPath = `source${path.sep}`;
 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 {
@@ -49,11 +35,6 @@ class Program {
      * 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:
@@ -63,26 +44,21 @@ 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 into this program, indexed by its original file location
          */
         this.files = {};
-        /**
-         * A map of every file loaded into this program, indexed by its destPath
-         */
-        this.destMap = new Map();
-        /**
-         * Plugins can contribute multiple virtual files for a single physical file.
-         * This collection links the virtual files back to the physical file that produced them.
-         * The key is the standardized and lower-cased srcPath
-         */
-        this.fileClusters = new Map();
+        this.pkgMap = {};
         this.scopes = {};
         /**
          * A map of every component currently loaded into the program, indexed by the component name.
@@ -91,111 +67,28 @@ 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.logger = logger !== null && logger !== void 0 ? logger : (0, logging_1.createLogger)(options);
         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();
-            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 componentData of Object.values(roku_types_1.components)) {
-            const nodeType = new types_1.InterfaceType(componentData.name);
-            nodeType.addBuiltInInterfaces();
-            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);
-        }
-        for (const nodeData of Object.values(roku_types_1.nodes)) {
-            this.recursivelyAddNodeToSymbolTable(nodeData);
-        }
-    }
-    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)
      */
@@ -231,7 +124,7 @@ class Program {
         var _a;
         if (componentName) {
             //return the first compoment in the list with this name
-            //(components are ordered in this list by destPath to ensure consistency)
+            //(components are ordered in this list by pkgPath to ensure consistency)
             return (_a = this.components[componentName.toLowerCase()]) === null || _a === void 0 ? void 0 : _a[0];
         }
         else {
@@ -242,7 +135,8 @@ class Program {
      * Register (or replace) the reference to a component in the component map
      */
     registerComponent(xmlFile, scope) {
-        const key = this.getComponentKey(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();
         if (!this.components[key]) {
             this.components[key] = [];
         }
@@ -251,8 +145,8 @@ class Program {
             scope: scope
         });
         this.components[key].sort((a, b) => {
-            const pathA = a.file.destPath.toLowerCase();
-            const pathB = b.file.destPath.toLowerCase();
+            const pathA = a.file.pkgPath.toLowerCase();
+            const pathB = b.file.pkgPath.toLowerCase();
             if (pathA < pathB) {
                 return -1;
             }
@@ -262,13 +156,13 @@ class Program {
             return 0;
         });
         this.syncComponentDependencyGraph(this.components[key]);
-        this.addDeferredComponentTypeSymbolCreation(xmlFile);
     }
     /**
      * Remove the specified component from the components map
      */
     unregisterComponent(xmlFile) {
-        const key = this.getComponentKey(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 arr = this.components[key] || [];
         for (let i = 0; i < arr.length; i++) {
             if (arr[i].file === xmlFile) {
@@ -277,44 +171,6 @@ 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
@@ -328,7 +184,6 @@ 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);
             }
@@ -355,7 +210,7 @@ class Program {
      * by walking through every file, so call this sparingly.
      */
     getDiagnostics() {
-        return this.logger.time(Logger_1.LogLevel.info, ['Program.getDiagnostics()'], () => {
+        return this.logger.time(logging_1.LogLevel.info, ['Program.getDiagnostics()'], () => {
             let diagnostics = [...this.diagnostics];
             //get the diagnostics from all scopes
             for (let scopeName in this.scopes) {
@@ -365,14 +220,14 @@ class Program {
             //get the diagnostics from all unreferenced files
             let unreferencedFiles = this.getUnreferencedFiles();
             for (let file of unreferencedFiles) {
-                diagnostics.push(...file.diagnostics);
+                diagnostics.push(...file.getDiagnostics());
             }
-            const filteredDiagnostics = this.logger.time(Logger_1.LogLevel.debug, ['filter diagnostics'], () => {
+            const filteredDiagnostics = this.logger.time(logging_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.logger.time(logging_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())}`);
@@ -390,9 +245,11 @@ class Program {
     hasFile(filePath, normalizePath = true) {
         return !!this.getFile(filePath, normalizePath);
     }
+    getPkgPath(...args) {
+        throw new Error('Not implemented');
+    }
     /**
      * roku filesystem is case INsensitive, so find the scope by key case insensitive
-     * @param scopeName xml scope names are their `destPath`. Source scope is stored with the key `"source"`
      */
     getScopeByName(scopeName) {
         if (!scopeName) {
@@ -400,8 +257,8 @@ class Program {
         }
         //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.toLowerCase()}`;
-        let key = Object.keys(this.scopes).find(x => x.toLowerCase() === scopeName);
+        scopeName = (0, util_1.standardizePath) `${scopeName}`;
+        let key = Object.keys(this.scopes).find(x => x.toLowerCase() === scopeName.toLowerCase());
         return this.scopes[key];
     }
     /**
@@ -421,14 +278,8 @@ 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.destMap.set(file.destPath.toLowerCase(), file);
-        this.plugins.emit('afterFileAdd', fileAddEvent);
+        this.pkgMap[file.pkgPath.toLowerCase()] = file;
         return file;
     }
     /**
@@ -436,102 +287,100 @@ class Program {
      */
     unassignFile(file) {
         delete this.files[file.srcPath.toLowerCase()];
-        this.destMap.delete(file.destPath.toLowerCase());
+        delete this.pkgMap[file.pkgPath.toLowerCase()];
         return file;
     }
-    setFile(fileParam, fileData) {
+    addOrReplaceFile(fileParam, fileContents) {
+        return this.setFile(fileParam, fileContents);
+    }
+    setFile(fileParam, fileContents) {
         //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;
+        const { srcPath, pkgPath } = this.getPaths(fileParam, this.options.rootDir);
+        let file = this.logger.time(logging_1.LogLevel.debug, ['Program.setFile()', chalk_1.default.green(srcPath)], () => {
             //if the file is already loaded, remove it
             if (this.hasFile(srcPath)) {
-                this.removeFile(srcPath, true, true);
+                this.removeFile(srcPath);
             }
-            const data = new LazyFileData_1.LazyFileData(fileData);
-            const event = new ProvideFileEventInternal(this, srcPath, destPath, data, this.fileFactory);
-            this.plugins.emit('beforeProvideFile', event);
-            this.plugins.emit('provideFile', event);
-            this.plugins.emit('afterProvideFile', event);
-            //if no files were provided, create a AssetFile to represent it.
-            if (event.files.length === 0) {
-                event.files.push(this.fileFactory.AssetFile({
-                    srcPath: event.srcPath,
-                    destPath: event.destPath,
-                    pkgPath: event.destPath,
-                    data: data
-                }));
-            }
-            //find the file instance for the srcPath that triggered this action.
-            const primaryFile = event.files.find(x => x.srcPath === srcPath);
-            if (!primaryFile) {
-                throw new Error(`No file provided for srcPath '${srcPath}'. Instead, received ${JSON.stringify(event.files.map(x => ({
-                    type: x.type,
-                    srcPath: x.srcPath,
-                    destPath: x.destPath
-                })))}`);
-            }
-            //link the virtual files to the primary file
-            this.fileClusters.set((_a = primaryFile.srcPath) === null || _a === void 0 ? void 0 : _a.toLowerCase(), event.files);
-            for (const file of event.files) {
-                file.srcPath = (0, util_1.standardizePath)(file.srcPath);
-                if (file.destPath) {
-                    file.destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(file.destPath, this.options.rootDir, '')}`;
-                }
-                if (file.pkgPath) {
-                    file.pkgPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(file.pkgPath, this.options.rootDir, '')}`;
-                }
-                else {
-                    file.pkgPath = file.destPath;
-                }
-                file.excludeFromOutput = file.excludeFromOutput === true;
-                //set the dependencyGraph key for every file to its destPath
-                file.dependencyGraphKey = file.destPath.toLowerCase();
-                this.assignFile(file);
-                //register a callback anytime this file's dependencies change
-                if (typeof file.onDependenciesChanged === 'function') {
-                    (_b = file.disposables) !== null && _b !== void 0 ? _b : (file.disposables = []);
-                    file.disposables.push(this.dependencyGraph.onchange(file.dependencyGraphKey, file.onDependenciesChanged.bind(file)));
-                }
-                //register this file (and its dependencies) with the dependency graph
-                this.dependencyGraph.addOrReplace(file.dependencyGraphKey, (_c = file.dependencies) !== null && _c !== void 0 ? _c : []);
-                //if this is a `source` file, add it to the source scope's dependency list
-                if (this.isSourceBrsFile(file)) {
+            let fileExtension = path.extname(srcPath).toLowerCase();
+            let file;
+            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(startOfSourcePkgPath)) {
                     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
-                    });
+                    this.dependencyGraph.addDependency('scope:source', brsFile.dependencyGraphKey);
                 }
+                let sourceObj = {
+                    //TODO remove `pathAbsolute` in v1
+                    pathAbsolute: srcPath,
+                    srcPath: srcPath,
+                    source: fileContents
+                };
+                this.plugins.emit('beforeFileParse', sourceObj);
+                this.logger.time(logging_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
+                    brsFile.parse(sourceObj.source);
+                });
+                //notify plugins that this file has finished parsing
+                this.plugins.emit('afterFileParse', brsFile);
+                file = brsFile;
+                brsFile.attachDependencyGraph(this.dependencyGraph);
+            }
+            else if (
+            //is xml file
+            fileExtension === '.xml' &&
+                //resides in the components folder (Roku will only parse xml files in the components folder)
+                pkgPath.toLowerCase().startsWith(util_1.util.pathSepNormalize(`components/`))) {
+                //add the file to the program
+                const xmlFile = this.assignFile(new XmlFile_1.XmlFile(srcPath, pkgPath, this));
+                let sourceObj = {
+                    //TODO remove `pathAbsolute` in v1
+                    pathAbsolute: srcPath,
+                    srcPath: srcPath,
+                    source: fileContents
+                };
+                this.plugins.emit('beforeFileParse', sourceObj);
+                this.logger.time(logging_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
+                    xmlFile.parse(sourceObj.source);
+                });
+                //notify plugins that this file has finished parsing
+                this.plugins.emit('afterFileParse', 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);
+                //notify plugins that the scope is created and the component is registered
+                this.plugins.emit('afterScopeCreate', scope);
+            }
+            else {
+                //TODO do we actually need to implement this? Figure out how to handle img paths
+                // let genericFile = this.files[srcPath] = <any>{
+                //     srcPath: srcPath,
+                //     pkgPath: pkgPath,
+                //     wasProcessed: true
+                // } as File;
+                // file = <any>genericFile;
             }
-            return primaryFile;
+            return file;
         });
         return file;
     }
     /**
-     * Given a srcPath, a destPath, or both, resolve whichever is missing, relative to rootDir.
+     * Given a srcPath, a pkgPath, 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;
+        let pkgPath;
         assert.ok(fileParam, 'fileParam is required');
-        //lift the path vars from the incoming param
+        //lift the srcPath and pkgPath 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, '')}`;
+            pkgPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
         }
         else {
             let param = fileParam;
@@ -542,30 +391,30 @@ class Program {
                 srcPath = (0, util_1.standardizePath) `${param.srcPath}`;
             }
             if (param.dest) {
-                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.dest)}`;
+                pkgPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.dest)}`;
             }
             if (param.pkgPath) {
-                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.pkgPath)}`;
+                pkgPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.pkgPath)}`;
             }
         }
-        //if there's no srcPath, use the destPath to build an absolute srcPath
+        //if there's no srcPath, use the pkgPath to build an absolute srcPath
         if (!srcPath) {
-            srcPath = (0, util_1.standardizePath) `${rootDir}/${destPath}`;
+            srcPath = (0, util_1.standardizePath) `${rootDir}/${pkgPath}`;
         }
         //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, '')}`;
+        //if there's no pkgPath, compute relative path from rootDir
+        if (!pkgPath) {
+            pkgPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
         }
         assert.ok(srcPath, 'fileEntry.src is required');
-        assert.ok(destPath, 'fileEntry.dest is required');
+        assert.ok(pkgPath, 'fileEntry.dest is required');
         return {
             srcPath: srcPath,
-            //remove leading slash
-            destPath: destPath.replace(/^[\/\\]+/, '')
+            //remove leading slash from pkgPath
+            pkgPath: pkgPath.replace(/^[\/\\]+/, '')
         };
     }
     /**
@@ -574,18 +423,6 @@ class Program {
     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.
      * Note: automatically called internally, and no-op if it exists already.
@@ -595,12 +432,42 @@ 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
-            });
+            this.plugins.emit('afterScopeCreate', sourceScope);
         }
     }
+    /**
+     * Find the file by its absolute path. This is case INSENSITIVE, since
+     * Roku is a case insensitive file system. It is an error to have multiple files
+     * with the same path with only case being different.
+     * @param srcPath the absolute path to the file
+     * @deprecated use `getFile` instead, which auto-detects the path type
+     */
+    getFileByPathAbsolute(srcPath) {
+        srcPath = (0, util_1.standardizePath) `${srcPath}`;
+        for (let filePath in this.files) {
+            if (filePath.toLowerCase() === srcPath.toLowerCase()) {
+                return this.files[filePath];
+            }
+        }
+    }
+    /**
+     * Get a list of files for the given (platform-normalized) pkgPath array.
+     * Missing files are just ignored.
+     * @deprecated use `getFiles` instead, which auto-detects the path types
+     */
+    getFilesByPkgPaths(pkgPaths) {
+        return pkgPaths
+            .map(pkgPath => this.getFileByPkgPath(pkgPath))
+            .filter(file => file !== undefined);
+    }
+    /**
+     * Get a file with the specified (platform-normalized) pkg path.
+     * If not found, return undefined
+     * @deprecated use `getFile` instead, which auto-detects the path type
+     */
+    getFileByPkgPath(pkgPath) {
+        return this.pkgMap[pkgPath.toLowerCase()];
+    }
     /**
      * Remove a set of files from the program
      * @param srcPaths can be an array of srcPath or destPath strings
@@ -613,197 +480,79 @@ class Program {
     }
     /**
      * Remove a file from the program
-     * @param filePath can be a srcPath, a destPath, or a destPath with leading `pkg:/`
+     * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `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, keepSymbolInformation = false) {
-        var _a, _b, _c, _d;
+    removeFile(filePath, normalizePath = true) {
         this.logger.debug('Program.removeFile()', filePath);
-        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);
+        let file = this.getFile(filePath, normalizePath);
+        if (file) {
+            this.plugins.emit('beforeFileDispose', file);
             //if there is a scope named the same as this file's path, remove it (i.e. xml scopes)
-            let scope = this.scopes[file.destPath];
+            let scope = this.scopes[file.pkgPath];
             if (scope) {
-                const scopeDisposeEvent = {
-                    program: this,
-                    scope: scope
-                };
-                this.plugins.emit('beforeScopeDispose', scopeDisposeEvent);
-                this.plugins.emit('onScopeDispose', scopeDisposeEvent);
+                this.plugins.emit('beforeScopeDispose', scope);
                 scope.dispose();
                 //notify dependencies of this scope that it has been removed
                 this.dependencyGraph.remove(scope.dependencyGraphKey);
-                delete this.scopes[file.destPath];
-                this.plugins.emit('afterScopeDispose', scopeDisposeEvent);
+                delete this.scopes[file.pkgPath];
+                this.plugins.emit('afterScopeDispose', scope);
             }
             //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 (this.isSourceBrsFile(file)) {
+            if (file.pkgPath.startsWith(startOfSourcePkgPath)) {
                 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 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);
+            file === null || file === void 0 ? void 0 : file.dispose();
+            this.plugins.emit('afterFileDispose', file);
         }
     }
     /**
      * Traverse the entire project, and validate all scopes
      */
     validate() {
-        this.logger.time(Logger_1.LogLevel.log, ['Validating project'], () => {
-            var _a, _b, _c, _d, _e, _f, _g;
+        this.logger.time(logging_1.LogLevel.log, ['Validating project'], () => {
+            var _a;
             this.diagnostics = [];
-            const programValidateEvent = {
-                program: this
-            };
-            this.plugins.emit('beforeProgramValidate', programValidateEvent);
-            this.plugins.emit('onProgramValidate', programValidateEvent);
+            this.plugins.emit('beforeProgramValidate', this);
             //validate every file
-            const brsFilesValidated = [];
             for (const file of Object.values(this.files)) {
                 //for every unvalidated file, validate it
                 if (!file.isValidated) {
-                    const validateFileEvent = {
+                    this.plugins.emit('beforeFileValidate', {
                         program: this,
                         file: file
-                    };
-                    this.plugins.emit('beforeFileValidate', validateFileEvent);
+                    });
                     //emit an event to allow plugins to contribute to the file validation process
-                    this.plugins.emit('onFileValidate', validateFileEvent);
+                    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);
                     file.isValidated = true;
-                    if ((0, reflection_1.isBrsFile)(file)) {
-                        brsFilesValidated.push(file);
-                    }
-                    this.plugins.emit('afterFileValidate', validateFileEvent);
-                }
-            }
-            // 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.plugins.emit('afterFileValidate', file);
                 }
-                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();
-            });
-            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'], () => {
+            this.logger.time(logging_1.LogLevel.info, ['Validate all scopes'], () => {
                 for (let scopeName in this.scopes) {
                     let scope = this.scopes[scopeName];
-                    scope.validate({ changedFiles: brsFilesValidated, changedSymbols: changedSymbols });
+                    scope.linkSymbolTable();
+                    scope.validate();
+                    scope.unlinkSymbolTable();
                 }
             });
             this.detectDuplicateComponentNames();
-            this.plugins.emit('afterProgramValidate', programValidateEvent);
+            this.plugins.emit('afterProgramValidate', this);
         });
     }
-    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
      */
@@ -856,13 +605,12 @@ class Program {
     getFile(filePath, normalizePath = true) {
         if (typeof filePath !== 'string') {
             return undefined;
-            //is the path absolute (or the `virtual:` prefix)
         }
-        else if (/^(?:(?:virtual:[\/\\])|(?:\w:)|(?:[\/\\]))/gmi.exec(filePath)) {
+        else if (path.isAbsolute(filePath)) {
             return this.files[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
         }
         else {
-            return this.destMap.get((normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase());
+            return this.pkgMap[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
         }
     }
     /**
@@ -870,14 +618,12 @@ class Program {
      * @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);
                 }
             }
@@ -904,8 +650,7 @@ class Program {
         //look through all files in scope for matches
         for (const scope of this.getScopesForFile(originFile)) {
             for (const file of scope.getAllFiles()) {
-                //skip non-brs files, or files we've already processed
-                if (!(0, reflection_1.isBrsFile)(file) || filesSearched.has(file)) {
+                if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
                     continue;
                 }
                 filesSearched.add(file);
@@ -929,7 +674,7 @@ class Program {
         let funcNames = new Set();
         let currentScope = scope;
         while ((0, reflection_1.isXmlScope)(currentScope)) {
-            for (let name of (_b = (_a = currentScope.xmlFile.ast.componentElement.interfaceElement) === null || _a === void 0 ? void 0 : _a.functions.map((f) => f.name)) !== null && _b !== void 0 ? _b : []) {
+            for (let name of (_b = (_a = currentScope.xmlFile.ast.component.api) === null || _a === void 0 ? void 0 : _a.functions.map((f) => f.name)) !== null && _b !== void 0 ? _b : []) {
                 if (!filterName || name === filterName) {
                     funcNames.add(name);
                 }
@@ -938,8 +683,7 @@ class Program {
         }
         //look through all files in scope for matches
         for (const file of scope.getOwnFiles()) {
-            //skip non-brs files, or files we've already processed
-            if (!(0, reflection_1.isBrsFile)(file) || filesSearched.has(file)) {
+            if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
                 continue;
             }
             filesSearched.add(file);
@@ -983,14 +727,14 @@ class Program {
      * Goes through each file and builds a list of workspace symbols for the program. Used by LanguageServer's onWorkspaceSymbol functionality
      */
     getWorkspaceSymbols() {
-        const results = Object.keys(this.files).map(key => {
-            const file = this.files[key];
-            if ((0, reflection_1.isBrsFile)(file)) {
-                return file.getWorkspaceSymbols();
-            }
-            return [];
-        });
-        return util_1.util.flatMap(results, c => c);
+        const event = {
+            program: this,
+            workspaceSymbols: []
+        };
+        this.plugins.emit('beforeProvideWorkspaceSymbols', event);
+        this.plugins.emit('provideWorkspaceSymbols', event);
+        this.plugins.emit('afterProvideWorkspaceSymbols', event);
+        return event.workspaceSymbols;
     }
     /**
      * Given a position in a file, if the position is sitting on some type of identifier,
@@ -1001,17 +745,16 @@ class Program {
         if (!file) {
             return [];
         }
-        if ((0, reflection_1.isBrsFile)(file)) {
-            return file.getDefinition(position);
-        }
-        else {
-            let results = [];
-            const scopes = this.getScopesForFile(file);
-            for (const scope of scopes) {
-                results = results.concat(...scope.getDefinition(file, position));
-            }
-            return results;
-        }
+        const event = {
+            program: this,
+            file: file,
+            position: position,
+            definitions: []
+        };
+        this.plugins.emit('beforeProvideDefinition', event);
+        this.plugins.emit('provideDefinition', event);
+        this.plugins.emit('afterProvideDefinition', event);
+        return event.definitions;
     }
     /**
      * Get hover information for a file and position
@@ -1034,6 +777,27 @@ class Program {
         }
         return result !== null && result !== void 0 ? result : [];
     }
+    /**
+     * Get full list of document symbols for a file
+     * @param srcPath path to the file
+     */
+    getDocumentSymbols(srcPath) {
+        let file = this.getFile(srcPath);
+        if (file) {
+            const event = {
+                program: this,
+                file: file,
+                documentSymbols: []
+            };
+            this.plugins.emit('beforeProvideDocumentSymbols', event);
+            this.plugins.emit('provideDocumentSymbols', event);
+            this.plugins.emit('afterProvideDocumentSymbols', event);
+            return event.documentSymbols;
+        }
+        else {
+            return undefined;
+        }
+    }
     /**
      * Compute code actions for the given file and range
      */
@@ -1088,12 +852,69 @@ class Program {
     getReferences(srcPath, position) {
         //find the file
         let file = this.getFile(srcPath);
-        if ((0, reflection_1.isBrsFile)(file) || (0, reflection_1.isXmlFile)(file)) {
-            return file.getReferences(position);
-        }
-        else {
+        if (!file) {
             return null;
         }
+        const event = {
+            program: this,
+            file: file,
+            position: position,
+            references: []
+        };
+        this.plugins.emit('beforeProvideReferences', event);
+        this.plugins.emit('provideReferences', event);
+        this.plugins.emit('afterProvideReferences', event);
+        return event.references;
+    }
+    /**
+     * 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 (let key in this.files) {
+            let 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, '/');
+                let pkgPathStandardized = file.pkgPath.replace(/\\/g, '/');
+                let filePkgPath = `pkg:/${pkgPathStandardized}`;
+                let lowerFilePkgPath = filePkgPath.toLowerCase();
+                if (!resultPkgPaths[lowerFilePkgPath]) {
+                    resultPkgPaths[lowerFilePkgPath] = 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: filePkgPath,
+                        detail: file.srcPath,
+                        kind: vscode_languageserver_1.CompletionItemKind.File,
+                        textEdit: {
+                            newText: filePkgPath,
+                            range: scriptImport.filePathRange
+                        }
+                    });
+                }
+            }
+        }
+        return result;
     }
     /**
      * Transpile a single file and get the result as a string.
@@ -1104,211 +925,162 @@ class Program {
      * @param filePath can be a srcPath or a destPath
      */
     async getTranspiledFileContents(filePath) {
-        const file = this.getFile(filePath);
-        return this.getTranspiledFileContentsPipeline.run(async () => {
-            const result = {
-                destPath: file.destPath,
-                pkgPath: file.pkgPath,
-                srcPath: file.srcPath
-            };
-            const expectedPkgPath = file.pkgPath.toLowerCase();
-            const expectedMapPath = `${expectedPkgPath}.map`;
-            const expectedTypedefPkgPath = expectedPkgPath.replace(/\.brs$/i, '.d.bs');
-            //add a temporary plugin to tap into the file writing process
-            const plugin = this.plugins.addFirst({
-                name: 'getTranspiledFileContents',
-                beforeWriteFile: (event) => {
-                    const pkgPath = event.file.pkgPath.toLowerCase();
-                    switch (pkgPath) {
-                        //this is the actual transpiled file
-                        case expectedPkgPath:
-                            result.code = event.file.data.toString();
-                            break;
-                        //this is the sourcemap
-                        case expectedMapPath:
-                            result.map = event.file.data.toString();
-                            break;
-                        //this is the typedef
-                        case expectedTypedefPkgPath:
-                            result.typedef = event.file.data.toString();
-                            break;
-                        default:
-                        //no idea what this file is. just ignore it
-                    }
-                    //mark every file as processed so it they don't get written to the output directory
-                    event.processedFiles.add(event.file);
-                }
-            });
-            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);
+        let fileMap = await roku_deploy_1.rokuDeploy.getFilePaths(this.options.files, this.options.rootDir);
+        //remove files currently loaded in the program, we will transpile those instead (even if just for source maps)
+        let filteredFileMap = [];
+        for (let fileEntry of fileMap) {
+            if (this.hasFile(fileEntry.src) === false) {
+                filteredFileMap.push(fileEntry);
             }
-            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 : '/')}`;
+        const { entries, astEditor } = this.beforeProgramTranspile(fileMap, this.options.stagingDir);
+        const result = this._getTranspiledFileContents(this.getFile(filePath));
+        this.afterProgramTranspile(entries, astEditor);
         return result;
     }
     /**
-     * Prepare the program for building
-     * @param files the list of files that should be prepared
+     * Internal function used to transpile files.
+     * This does not write anything to the file system
      */
-    async prepare(files) {
-        const programEvent = {
+    _getTranspiledFileContents(file, outputPath) {
+        const editor = new AstEditor_1.AstEditor();
+        this.plugins.emit('beforeFileTranspile', {
             program: this,
-            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;
-            }
+            file: file,
+            outputPath: outputPath,
+            editor: editor
         });
-        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);
+        //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);
         }
-        await this.plugins.emitAsync('afterPrepareProgram', programEvent);
-        return files;
-    }
-    /**
-     * Generate the contents of every file
-     */
-    async serialize(files) {
-        const allFiles = new Map();
-        const serializeProgramEvent = await this.plugins.emitAsync('beforeSerializeProgram', {
-            program: this,
-            files: files,
-            result: allFiles
-        });
-        await this.plugins.emitAsync('onSerializeProgram', {
-            program: this,
-            files: files,
-            result: allFiles
-        });
-        //sort the entries to make transpiling more deterministic
-        files = serializeProgramEvent.files.sort((a, b) => {
-            return a.srcPath < b.srcPath ? -1 : 1;
-        });
-        // serialize each file
-        for (const file of files) {
-            const event = {
-                program: this,
-                file: file,
-                result: allFiles
-            };
-            await this.plugins.emitAsync('beforeSerializeFile', event);
-            await this.plugins.emitAsync('serializeFile', event);
-            await this.plugins.emitAsync('afterSerializeFile', event);
+        //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();
         }
-        this.plugins.emit('afterSerializeProgram', {
+        const event = {
             program: this,
-            files: files,
-            result: allFiles
-        });
-        return allFiles;
+            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
+        };
     }
-    /**
-     * Write the entire project to disk
-     */
-    async write(stagingDir, files) {
-        const programEvent = await this.plugins.emitAsync('beforeWriteProgram', {
-            program: this,
-            files: files,
-            stagingDir: stagingDir
-        });
-        //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,
+    beforeProgramTranspile(fileEntries, stagingDir) {
+        // 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:/${file.pkgPath}`,
+                    dest: file.pkgPath
+                };
+            }
+            //replace the file extension
+            let outputPath = filePathObj.dest.replace(/\.bs$/gi, '.brs');
+            //prepend the staging folder path
+            outputPath = (0, util_1.standardizePath) `${stagingDir}/${outputPath}`;
+            return outputPath;
+        };
+        const entries = Object.values(this.files).map(file => {
+            return {
                 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);
+                outputPath: getOutputPath(file)
+            };
+            //sort the entries to make transpiling more deterministic
+        }).sort((a, b) => {
+            return a.file.srcPath < b.file.srcPath ? -1 : 1;
+        });
+        const astEditor = new AstEditor_1.AstEditor();
+        this.plugins.emit('beforeProgramTranspile', this, entries, astEditor);
+        return {
+            entries: entries,
+            getOutputPath: getOutputPath,
+            astEditor: astEditor
+        };
     }
-    /**
-     * Build the project. This transpiles/transforms/copies all files and moves them to the staging directory
-     * @param options the list of options used to build the program
-     */
-    async build(options) {
-        //run a single build at a time
-        await this.buildPipeline.run(async () => {
-            var _a;
-            const stagingDir = this.getStagingDir(options === null || options === void 0 ? void 0 : options.stagingDir);
-            const event = await this.plugins.emitAsync('beforeBuildProgram', {
-                program: this,
-                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();
+    async transpile(fileEntries, stagingDir) {
+        const { entries, getOutputPath, astEditor } = this.beforeProgramTranspile(fileEntries, stagingDir);
+        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(outputPath === null || outputPath === void 0 ? void 0 : outputPath.toLowerCase());
+            if (!this.options.pruneEmptyCodeFiles || !file.canBePruned) {
+                //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) => {
+            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) `source/bslib.brs`)) {
+            promises.push(util_1.util.copyBslibToStaging(stagingDir, this.options.bslibDestinationDir));
+        }
+        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
+                const outputPath = getOutputPath(file);
+                if (!processedFiles.has(outputPath === null || outputPath === void 0 ? void 0 : outputPath.toLowerCase())) {
+                    promises.push(transpileFile(file === null || file === void 0 ? void 0 : file.srcPath, outputPath));
+                }
+            }
+            if (promises.length > 0) {
+                this.logger.info(`Transpiling ${promises.length} new files`);
+                await Promise.all(promises);
+            }
+        } while (promises.length > 0);
+        this.afterProgramTranspile(entries, astEditor);
+    }
+    afterProgramTranspile(entries, astEditor) {
+        this.plugins.emit('afterProgramTranspile', this, entries, astEditor);
+        astEditor.undoAll();
     }
     /**
      * Find a list of files in the program that have a function with the given name (case INsensitive)
@@ -1380,70 +1152,75 @@ class Program {
         return files;
     }
     /**
-     * Get a map of the manifest information
+     * 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
      */
-    getManifest() {
+    buildBsConstsIntoParsedManifest(parsedManifest) {
         var _a, _b;
-        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');
-                let parsedManifest = (0, Manifest_1.parseManifest)(contents);
-                // 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);
-                this._manifest = parsedManifest;
+        // 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);
             }
-            catch (err) {
-                this._manifest = new Map();
+            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) {
+            this.loadManifest();
+        }
         return this._manifest;
     }
     dispose() {
-        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);
+            this.files[filePath].dispose();
         }
         for (let name in this.scopes) {
-            (_d = (_c = this.scopes[name]) === null || _c === void 0 ? void 0 : _c.dispose) === null || _d === void 0 ? void 0 : _d.call(_c);
+            this.scopes[name].dispose();
         }
-        (_f = (_e = this.globalScope) === null || _e === void 0 ? void 0 : _e.dispose) === null || _f === void 0 ? void 0 : _f.call(_e);
-        (_h = (_g = this.dependencyGraph) === null || _g === void 0 ? void 0 : _g.dispose) === null || _h === void 0 ? void 0 : _h.call(_g);
+        this.globalScope.dispose();
+        this.dependencyGraph.dispose();
     }
 }
 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