brighterscript 0.41.2 → 1.0.0-alpha.12

package/dist/Program.js

@@ -23,9 +23,9 @@ const reflection_1 = require("./astUtils/reflection");
 const parser_1 = require("./parser");
 const lexer_1 = require("./lexer");
 const BscPlugin_1 = require("./bscPlugin/BscPlugin");
-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`;
+const roku_deploy_1 = require("roku-deploy");
+const bslibNonAliasedRokuModulesPkgPath = `pkg:/source/roku_modules/rokucommunity_bslib/bslib.brs`;
+const bslibAliasedRokuModulesPkgPath = `pkg:/source/roku_modules/bslib/bslib.brs`;
 class Program {
     constructor(
     /**
@@ -47,10 +47,13 @@ class Program {
          */
         this.diagnostics = [];
         /**
-         * A map of every file loaded into this program, indexed by its original file location
+         * A map of every file loaded ino this program, indexed by its lower-case pkgPath
          */
-        this.files = {};
         this.pkgMap = {};
+        /**
+         * A map of every file loaded into this program, indexed by its lower-case srcPath
+         */
+        this.files = {};
         this.scopes = {};
         /**
          * A map of every component currently loaded into the program, indexed by the component name.
@@ -86,16 +89,16 @@ class Program {
      */
     get bslibPkgPath() {
         //if there's an aliased (preferred) version of bslib from roku_modules loaded into the program, use that
-        if (this.getFileByPkgPath(bslibAliasedRokuModulesPkgPath)) {
+        if (this.getFile(bslibAliasedRokuModulesPkgPath)) {
             return bslibAliasedRokuModulesPkgPath;
             //if there's a non-aliased version of bslib from roku_modules, use that
         }
-        else if (this.getFileByPkgPath(bslibNonAliasedRokuModulesPkgPath)) {
+        else if (this.getFile(bslibNonAliasedRokuModulesPkgPath)) {
             return bslibNonAliasedRokuModulesPkgPath;
             //default to the embedded version
         }
         else {
-            return `source${path.sep}bslib.brs`;
+            return `pkg:/source/bslib.brs`;
         }
     }
     get bslibPrefix() {
@@ -106,9 +109,18 @@ class Program {
             return 'bslib';
         }
     }
+    /**
+     * Get a copy of the list of files currently loaded in the program
+     */
+    getFiles() {
+        return Object.values(this.files);
+    }
     addScope(scope) {
         this.scopes[scope.name] = scope;
-        this.plugins.emit('afterScopeCreate', scope);
+        this.plugins.emit('afterScopeCreate', {
+            program: this,
+            scope: scope
+        });
     }
     /**
      * Get the component with the specified name
@@ -178,8 +190,8 @@ class Program {
      */
     getUnreferencedFiles() {
         let result = [];
-        for (let filePath in this.files) {
-            let file = this.files[filePath];
+        for (let key in this.files) {
+            const file = this.files[key];
             if (!this.fileIsIncludedInAnyScope(file)) {
                 //no scopes reference this file. add it to the list
                 result.push(file);
@@ -219,13 +231,10 @@ class Program {
     /**
      * Determine if the specified file is loaded in this program right now.
      * @param filePath
+     * @param normalizePath should the provided path be normalized before use
      */
-    hasFile(filePath) {
-        filePath = (0, util_1.standardizePath) `${filePath}`;
-        return this.files[filePath] !== undefined;
-    }
-    getPkgPath(...args) {
-        throw new Error('Not implemented');
+    hasFile(filePath, normalizePath = true) {
+        return !!this.getFile(filePath, normalizePath);
     }
     /**
      * roku filesystem is case INsensitive, so find the scope by key case insensitive
@@ -235,9 +244,6 @@ class Program {
         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];
     }
@@ -254,65 +260,94 @@ class Program {
         var _a;
         return (_a = this.getComponent(componentName)) === null || _a === void 0 ? void 0 : _a.scope;
     }
-    addOrReplaceFile(fileParam, fileContents) {
-        assert.ok(fileParam, 'fileEntry is required');
+    /**
+     * Update internal maps with this file reference
+     */
+    assignFile(file) {
+        this.files[file.srcPath.toLowerCase()] = file;
+        this.pkgMap[file.pkgPath.toLowerCase()] = file;
+    }
+    /**
+     * Remove this file from internal maps
+     */
+    unassignFile(file) {
+        delete this.files[file.srcPath.toLowerCase()];
+        delete this.pkgMap[file.pkgPath.toLowerCase()];
+    }
+    setFile(fileParam, fileContents) {
+        assert.ok(fileParam, 'fileParam is required');
         let srcPath;
         let pkgPath;
         if (typeof fileParam === 'string') {
-            srcPath = (0, util_1.standardizePath) `${this.options.rootDir}/${fileParam}`;
-            pkgPath = (0, util_1.standardizePath) `${fileParam}`;
+            //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)
+            }
+            else if (path.isAbsolute(fileParam)) {
+                srcPath = util_1.util.standardizePath(fileParam);
+                //assume the file path is a sub path of rootDir
+                pkgPath = util_1.util.sanitizePkgPath(roku_deploy_1.util.stringReplaceInsensitive(srcPath, this.options.rootDir, ''));
+                //is destPath (path relative to rootDir and `pkg:/`)
+            }
+            else {
+                srcPath = (0, util_1.standardizePath) `${this.options.rootDir}/${fileParam}`;
+                pkgPath = util_1.util.sanitizePkgPath(fileParam);
+            }
+            //is a FileObj
         }
         else {
             srcPath = (0, util_1.standardizePath) `${fileParam.src}`;
-            pkgPath = (0, util_1.standardizePath) `${fileParam.dest}`;
+            pkgPath = util_1.util.sanitizePkgPath(fileParam.dest);
         }
-        let file = this.logger.time(Logger_1.LogLevel.debug, ['Program.addOrReplaceFile()', chalk_1.default.green(srcPath)], () => {
-            assert.ok(srcPath, 'fileEntry.src is required');
-            assert.ok(pkgPath, 'fileEntry.dest is required');
+        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 fileExtension = path.extname(srcPath).toLowerCase();
             let file;
+            const beforeFileParseEvent = {
+                program: this,
+                srcPath: srcPath,
+                source: fileContents
+            };
             if (fileExtension === '.brs' || fileExtension === '.bs') {
                 let brsFile = new BrsFile_1.BrsFile(srcPath, pkgPath, this);
                 //add file to the `source` dependency list
-                if (brsFile.pkgPath.startsWith(startOfSourcePkgPath)) {
+                if (brsFile.pkgPath.startsWith('pkg:/source/')) {
                     this.createSourceScope();
                     this.dependencyGraph.addDependency('scope:source', brsFile.dependencyGraphKey);
                 }
                 //add the file to the program
-                this.files[srcPath] = brsFile;
-                this.pkgMap[brsFile.pkgPath.toLowerCase()] = brsFile;
-                let sourceObj = {
-                    pathAbsolute: srcPath,
-                    source: fileContents
-                };
-                this.plugins.emit('beforeFileParse', sourceObj);
+                this.assignFile(brsFile);
+                this.plugins.emit('beforeFileParse', beforeFileParseEvent);
                 this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
-                    brsFile.parse(sourceObj.source);
+                    brsFile.parse(beforeFileParseEvent.source);
                 });
                 file = brsFile;
                 brsFile.attachDependencyGraph(this.dependencyGraph);
-                this.plugins.emit('afterFileValidate', brsFile);
+                this.plugins.emit('afterFileParse', {
+                    program: this,
+                    file: brsFile
+                });
             }
             else if (
             //is xml file
             fileExtension === '.xml' &&
                 //resides in the components folder (Roku will only parse xml files in the components folder)
-                pkgPath.toLowerCase().startsWith(util_1.util.pathSepNormalize(`components/`))) {
+                lowerPkgPath.startsWith('pkg:/components/')) {
                 let xmlFile = new XmlFile_1.XmlFile(srcPath, pkgPath, this);
+                this.assignFile(xmlFile);
                 //add the file to the program
-                this.files[srcPath] = xmlFile;
-                this.pkgMap[xmlFile.pkgPath.toLowerCase()] = xmlFile;
-                let sourceObj = {
-                    pathAbsolute: srcPath,
-                    source: fileContents
-                };
-                this.plugins.emit('beforeFileParse', sourceObj);
+                this.plugins.emit('beforeFileParse', beforeFileParseEvent);
                 this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
-                    xmlFile.parse(sourceObj.source);
+                    xmlFile.parse(beforeFileParseEvent.source);
                 });
                 file = xmlFile;
                 //create a new scope for this xml file
@@ -320,12 +355,15 @@ class Program {
                 this.addScope(scope);
                 //register this compoent now that we have parsed it and know its component name
                 this.registerComponent(xmlFile, scope);
-                this.plugins.emit('afterFileValidate', xmlFile);
+                this.plugins.emit('afterFileParse', {
+                    program: this,
+                    file: xmlFile
+                });
             }
             else {
                 //TODO do we actually need to implement this? Figure out how to handle img paths
-                // let genericFile = this.files[pathAbsolute] = <any>{
-                //     pathAbsolute: pathAbsolute,
+                // let genericFile = this.files[srcPath] = <any>{
+                //     srcPath: srcPath,
                 //     pkgPath: pkgPath,
                 //     wasProcessed: true
                 // } as File;
@@ -333,7 +371,6 @@ class Program {
             }
             return file;
         });
-        return file;
     }
     /**
      * Ensure source scope is created.
@@ -346,80 +383,79 @@ class Program {
             this.addScope(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 pathAbsolute
-     */
-    getFileByPathAbsolute(pathAbsolute) {
-        pathAbsolute = (0, util_1.standardizePath) `${pathAbsolute}`;
-        for (let filePath in this.files) {
-            if (filePath.toLowerCase() === pathAbsolute.toLowerCase()) {
-                return this.files[filePath];
-            }
-        }
-    }
-    /**
-     * Get a list of files for the given (platform-normalized) pkgPath array.
-     * Missing files are just ignored.
-     */
-    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
-     */
-    getFileByPkgPath(pkgPath) {
-        return this.pkgMap[pkgPath.toLowerCase()];
-    }
     /**
      * Remove a set of files from the program
-     * @param absolutePaths
+     * @param srcPaths
      */
-    removeFiles(absolutePaths) {
-        for (let pathAbsolute of absolutePaths) {
-            this.removeFile(pathAbsolute);
+    removeFiles(srcPaths) {
+        for (let srcPath of srcPaths) {
+            this.removeFile(srcPath);
         }
     }
     /**
      * Remove a file from the program
-     * @param pathAbsolute
+     * @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(pathAbsolute) {
-        this.logger.debug('Program.removeFile()', pathAbsolute);
-        if (!path.isAbsolute(pathAbsolute)) {
-            throw new Error(`Path must be absolute: "${pathAbsolute}"`);
-        }
-        let file = this.getFile(pathAbsolute);
+    removeFile(filePath, normalizePath = true) {
+        this.logger.debug('Program.removeFile()', filePath);
+        let file = this.getFile(filePath, normalizePath);
         if (file) {
-            this.plugins.emit('beforeFileDispose', file);
+            this.plugins.emit('beforeFileDispose', {
+                program: this,
+                file: 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.pkgPath];
             if (scope) {
-                this.plugins.emit('beforeScopeDispose', scope);
+                this.plugins.emit('beforeScopeDispose', {
+                    program: this,
+                    scope: scope
+                });
                 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', scope);
+                this.plugins.emit('afterScopeDispose', {
+                    program: this,
+                    scope: scope
+                });
             }
             //remove the file from the program
-            delete this.files[file.pathAbsolute];
-            delete this.pkgMap[file.pkgPath.toLowerCase()];
+            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(startOfSourcePkgPath)) {
+            if (file.pkgPath.startsWith('pkg:/source/')) {
                 this.dependencyGraph.removeDependency('scope:source', file.dependencyGraphKey);
             }
             //if this is a component, remove it from our components map
             if ((0, reflection_1.isXmlFile)(file)) {
                 this.unregisterComponent(file);
             }
-            this.plugins.emit('afterFileDispose', file);
+            this.plugins.emit('afterFileDispose', {
+                program: this,
+                file: file
+            });
+        }
+    }
+    /**
+     * Remove all files from the program that are in the specified folder path (recursive)
+     * @param folderSrcPath The absolute path to the folder on disk
+     * @param normalizePath should the provided path be normalized before use?
+     */
+    removeFilesInFolder(folderSrcPath, normalizePath = true) {
+        if (normalizePath) {
+            folderSrcPath = util_1.util.standardizePath(folderSrcPath);
+        }
+        const lowerFolderSrcPath = folderSrcPath.toLowerCase();
+        for (const key in this.files) {
+            const file = this.files[key];
+            const lowerSrcPath = file.srcPath.toLowerCase();
+            //if the file path starts with the parent path and the file path does not exactly match the folder path
+            if (lowerSrcPath.toLowerCase().startsWith(lowerFolderSrcPath) && lowerSrcPath !== lowerFolderSrcPath) {
+                this.removeFile(file.srcPath, false);
+            }
         }
     }
     /**
@@ -428,53 +464,86 @@ class Program {
      */
     validate() {
         this.logger.time(Logger_1.LogLevel.log, ['Validating project'], () => {
+            var _a;
             this.diagnostics = [];
-            this.plugins.emit('beforeProgramValidate', this);
-            this.logger.time(Logger_1.LogLevel.info, ['Validate all scopes'], () => {
-                for (let scopeName in this.scopes) {
-                    let scope = this.scopes[scopeName];
-                    scope.validate();
-                }
+            this.plugins.emit('beforeProgramValidate', {
+                program: this
             });
-            //find any files NOT loaded into a scope
-            for (let filePath in this.files) {
-                let file = this.files[filePath];
+            //validate every file
+            for (const file of Object.values(this.files)) {
+                //find any files NOT loaded into a scope
                 if (!this.fileIsIncludedInAnyScope(file)) {
                     this.logger.debug('Program.validate(): fileNotReferenced by any scope', () => chalk_1.default.green(file === null || file === void 0 ? void 0 : file.pkgPath));
                     //the file is not loaded in any scope
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.fileNotReferencedByAnyOtherFile()), { file: file, range: util_1.util.createRange(0, 0, 0, Number.MAX_VALUE) }));
                 }
+                //for every unvalidated file, validate it
+                if (!file.isValidated) {
+                    this.plugins.emit('beforeFileValidate', {
+                        program: this,
+                        file: file
+                    });
+                    //call file.validate() IF the file has that function defined
+                    (_a = file.validate) === null || _a === void 0 ? void 0 : _a.call(file);
+                    file.isValidated = true;
+                    this.plugins.emit('afterFileValidate', {
+                        program: this,
+                        file: file
+                    });
+                }
             }
+            this.logger.time(Logger_1.LogLevel.info, ['Validate all scopes'], () => {
+                for (let scope of Object.values(this.scopes)) {
+                    //only validate unvalidated scopes
+                    if (!scope.isValidated) {
+                        this.plugins.emit('beforeScopeValidate', {
+                            program: this,
+                            scope: scope
+                        });
+                        scope.validate();
+                        scope.isValidated = true;
+                        this.plugins.emit('afterScopeValidate', {
+                            program: this,
+                            scope: scope
+                        });
+                    }
+                }
+            });
             this.detectDuplicateComponentNames();
-            this.plugins.emit('afterProgramValidate', this);
+            this.plugins.emit('afterProgramValidate', {
+                program: this
+            });
         });
     }
     /**
      * Flag all duplicate component names
      */
     detectDuplicateComponentNames() {
-        const componentsByName = Object.keys(this.files).reduce((map, filePath) => {
-            var _a;
-            const file = this.files[filePath];
+        var _a;
+        const componentsByName = new Map();
+        for (const key in this.files) {
+            const file = this.files[key];
             //if this is an XmlFile, and it has a valid `componentName` property
-            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] = [];
+            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);
+                    }
                 }
-                map[lowerName].push(file);
             }
-            return map;
-        }, {});
-        for (let name in componentsByName) {
-            const xmlFiles = componentsByName[name];
+        }
+        for (const xmlFiles of componentsByName.values()) {
             //add diagnostics for every duplicate component with this name
             if (xmlFiles.length > 1) {
                 for (let xmlFile of xmlFiles) {
                     const { componentName } = xmlFile;
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateComponentName(componentName.text)), { range: xmlFile.componentName.range, file: xmlFile, relatedInformation: xmlFiles.filter(x => x !== xmlFile).map(x => {
                             return {
-                                location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(xmlFile.pathAbsolute).toString(), x.componentName.range),
+                                location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(xmlFile.srcPath).toString(), x.componentName.range),
                                 message: 'Also defined here'
                             };
                         }) }));
@@ -483,11 +552,11 @@ class Program {
         }
     }
     /**
-     * Determine if the given file is included in at least one scope in this program
+     * Determine at least one scope has the file
      */
     fileIsIncludedInAnyScope(file) {
-        for (let scopeName in this.scopes) {
-            if (this.scopes[scopeName].hasFile(file)) {
+        for (let scope of Object.values(this.scopes)) {
+            if (scope.hasFile(file)) {
                 return true;
             }
         }
@@ -495,11 +564,19 @@ class Program {
     }
     /**
      * Get the file at the given path
-     * @param pathAbsolute
+     * @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
      */
-    getFile(pathAbsolute) {
-        pathAbsolute = (0, util_1.standardizePath) `${pathAbsolute}`;
-        return this.files[pathAbsolute];
+    getFile(filePath, normalizePath = true) {
+        if (typeof filePath !== 'string') {
+            return undefined;
+        }
+        else if (path.isAbsolute(filePath)) {
+            return this.files[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
+        }
+        else {
+            return this.pkgMap[(normalizePath ? util_1.util.sanitizePkgPath(filePath) : filePath).toLowerCase()];
+        }
     }
     /**
      * Get a list of all scopes the file is loaded into
@@ -548,9 +625,12 @@ class Program {
         let funcNames = new Set();
         let currentScope = scope;
         while ((0, reflection_1.isXmlScope)(currentScope)) {
-            for (let name of (_b = (_a = currentScope.xmlFile.ast.component.api) === null || _a === void 0 ? void 0 : _a.functions.map((f) => f.name)) !== null && _b !== void 0 ? _b : []) {
-                if (!filterName || name === filterName) {
-                    funcNames.add(name);
+            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);
+                    }
                 }
             }
             currentScope = currentScope.getParentScope();
@@ -573,17 +653,17 @@ class Program {
     }
     /**
      * Find all available completion items at the given position
-     * @param pathAbsolute
+     * @param srcPath The absolute path to the source file on disk
      * @param lineIndex
      * @param columnIndex
      */
-    getCompletions(pathAbsolute, position) {
-        let file = this.getFile(pathAbsolute);
+    getCompletions(srcPath, position) {
+        let file = this.getFile(srcPath);
         if (!file) {
             return [];
         }
         let result = [];
-        if ((0, reflection_1.isBrsFile)(file) && file.isPositionNextToTokenKind(position, lexer_1.TokenKind.Callfunc)) {
+        if ((0, reflection_1.isBrsFile)(file) && file.parser.isPositionNextToTokenKind(position, lexer_1.TokenKind.Callfunc)) {
             // is next to a @. callfunc invocation - must be an interface method
             for (const scope of this.getScopes().filter((s) => (0, reflection_1.isXmlScope)(s))) {
                 let fileLinks = this.getStatementsForXmlFile(scope);
@@ -599,7 +679,12 @@ class Program {
         //if there are no scopes, include the global scope so we at least get the built-in functions
         scopes = scopes.length > 0 ? scopes : [this.globalScope];
         //get the completions from all scopes for this file
-        let allCompletions = util_1.util.flatMap(scopes.map(ctx => file.getCompletions(position, ctx)), c => c);
+        let allCompletions = util_1.util.flatMap(scopes.map(ctx => {
+            ctx.linkSymbolTable();
+            const completions = file.getCompletions(position, ctx);
+            ctx.unlinkSymbolTable();
+            return completions;
+        }), c => c);
         //only keep completions common to every scope for this file
         let keyCounts = {};
         for (let completion of allCompletions) {
@@ -615,21 +700,22 @@ 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 result = [];
+        for (const key in this.files) {
             const file = this.files[key];
             if ((0, reflection_1.isBrsFile)(file)) {
-                return file.getWorkspaceSymbols();
+                result.push(...file.getWorkspaceSymbols());
             }
-            return [];
-        });
-        return util_1.util.flatMap(results, c => c);
+        }
+        return result;
     }
     /**
      * 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(pathAbsolute, position) {
-        let file = this.getFile(pathAbsolute);
+    getDefinition(srcPath, position) {
+        let file = this.getFile(srcPath);
         if (!file) {
             return [];
         }
@@ -645,9 +731,12 @@ class Program {
             return results;
         }
     }
-    getHover(pathAbsolute, position) {
+    /**
+     * @param srcPath The absolute path to the source file on disk
+     */
+    getHover(srcPath, position) {
         //find the file
-        let file = this.getFile(pathAbsolute);
+        let file = this.getFile(srcPath);
         if (!file) {
             return null;
         }
@@ -655,10 +744,11 @@ class Program {
     }
     /**
      * Compute code actions for the given file and range
+     * @param srcPath The absolute path to the source file on disk
      */
-    getCodeActions(pathAbsolute, range) {
+    getCodeActions(srcPath, range) {
         const codeActions = [];
-        const file = this.getFile(pathAbsolute);
+        const file = this.getFile(srcPath);
         if (file) {
             const diagnostics = this
                 //get all current diagnostics (filtered by diagnostic filters)
@@ -702,7 +792,7 @@ class Program {
             return [];
         }
         const results = new Map();
-        let functionScope = file.getFunctionScopeAtPosition(position);
+        let functionExpression = file.getFunctionExpressionAtPosition(position);
         let identifierInfo = this.getPartialStatementInfo(file, position);
         if (identifierInfo.statementType === '') {
             // just general function calls
@@ -720,10 +810,12 @@ class Program {
         else if (identifierInfo.statementType === '.') {
             //if m class reference.. then
             //only get statements from the class I am in..
-            if (functionScope) {
-                let myClass = file.getClassFromMReference(position, file.getTokenAt(position), functionScope);
-                if (myClass) {
-                    for (let scope of this.getScopesForFile(myClass.file)) {
+            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.isClassMethodStatement)(i.item))) {
@@ -734,6 +826,7 @@ class Program {
                             }
                         }
                     }
+                    scope.unlinkSymbolTable();
                 }
             }
             if (identifierInfo.dotPart) {
@@ -794,12 +887,12 @@ class Program {
         if (!itemCounts.isArgStartFound) {
             //try to get sig help based on the name
             index = position.character;
-            let currentToken = file.getTokenAt(position);
+            let currentToken = file.parser.getTokenAt(position);
             if (currentToken && currentToken.kind !== lexer_1.TokenKind.Comment) {
                 name = file.getPartialVariableName(currentToken, [lexer_1.TokenKind.New]);
                 if (!name) {
                     //try the previous token, incase we're on a bracket
-                    currentToken = file.getPreviousToken(currentToken);
+                    currentToken = file.parser.getPreviousToken(currentToken);
                     name = file.getPartialVariableName(currentToken, [lexer_1.TokenKind.New]);
                 }
                 if (name === null || name === void 0 ? void 0 : name.indexOf('.')) {
@@ -906,9 +999,12 @@ class Program {
         }
         return itemCounts;
     }
-    getReferences(pathAbsolute, position) {
+    /**
+     * @param srcPath The absolute path to the source file on disk
+     */
+    getReferences(srcPath, position) {
         //find the file
-        let file = this.getFile(pathAbsolute);
+        let file = this.getFile(srcPath);
         if (!file) {
             return null;
         }
@@ -926,8 +1022,8 @@ class Program {
          */
         let resultPkgPaths = {};
         //restrict to only .brs files
-        for (let key in this.files) {
-            let file = this.files[key];
+        for (const key in this.files) {
+            const file = this.files[key];
             if (
             //is a BrightScript or BrighterScript file
             (file.extension === '.bs' || file.extension === '.brs') &&
@@ -935,14 +1031,12 @@ class Program {
                 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;
+                const lowerPkgPath = file.pkgPath.toLowerCase();
+                if (!resultPkgPaths[lowerPkgPath]) {
+                    resultPkgPaths[lowerPkgPath] = true;
                     result.push({
                         label: relativePath,
-                        detail: file.pathAbsolute,
+                        detail: file.srcPath,
                         kind: vscode_languageserver_1.CompletionItemKind.File,
                         textEdit: {
                             newText: relativePath,
@@ -951,11 +1045,11 @@ class Program {
                     });
                     //add the absolute path
                     result.push({
-                        label: filePkgPath,
-                        detail: file.pathAbsolute,
+                        label: file.pkgPath,
+                        detail: file.srcPath,
                         kind: vscode_languageserver_1.CompletionItemKind.File,
                         textEdit: {
-                            newText: filePkgPath,
+                            newText: file.pkgPath,
                             range: scriptImport.filePathRange
                         }
                     });
@@ -967,50 +1061,64 @@ class Program {
     /**
      * Transpile a single file and get the result as a string.
      * This does not write anything to the file system.
+     * @param srcPath The absolute path to the source file on disk
      */
-    getTranspiledFileContents(pathAbsolute) {
-        let file = this.getFile(pathAbsolute);
+    getTranspiledFileContents(srcPath) {
+        let file = this.getFile(srcPath);
         let result = file.transpile();
-        return Object.assign(Object.assign({}, result), { pathAbsolute: file.pathAbsolute, pkgPath: file.pkgPath });
+        return Object.assign(Object.assign({}, result), { srcPath: file.srcPath, pkgPath: file.pkgPath });
     }
     async transpile(fileEntries, stagingFolderPath) {
-        // map fileEntries using their path as key, to avoid excessive "find()" operations
+        // 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 entries = Object.values(this.files).map(file => {
-            let filePathObj = mappedFileEntries[(0, util_1.standardizePath) `${file.pathAbsolute}`];
+        const entries = [];
+        for (const key in this.files) {
+            const file = this.files[key];
+            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}`,
+                    src: `bsc-in-memory:/${util_1.util.removeProtocol(file.pkgPath)}`,
                     dest: file.pkgPath
                 };
             }
-            //replace the file extension
-            let outputPath = filePathObj.dest.replace(/\.bs$/gi, '.brs');
+            //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 {
+            entries.push({
                 file: file,
                 outputPath: outputPath
-            };
+            });
+        }
+        this.plugins.emit('beforeProgramTranspile', {
+            program: this,
+            entries: entries
         });
-        this.plugins.emit('beforeProgramTranspile', this, entries);
         const promises = entries.map(async (entry) => {
             //skip transpiling typedef files
             if ((0, reflection_1.isBrsFile)(entry.file) && entry.file.isTypedef) {
                 return;
             }
-            this.plugins.emit('beforeFileTranspile', entry);
+            this.plugins.emit('beforeFileTranspile', {
+                program: this,
+                file: entry.file,
+                outputPath: entry.outputPath
+            });
             const { file, outputPath } = entry;
             const result = file.transpile();
             //make sure the full dir path exists
             await fsExtra.ensureDir(path.dirname(outputPath));
             if (await fsExtra.pathExists(outputPath)) {
-                throw new Error(`Error while transpiling "${file.pathAbsolute}". A file already exists at "${outputPath}" and will not be overwritten.`);
+                throw new Error(`Error while transpiling "${file.srcPath}". A file already exists at "${outputPath}" and will not be overwritten.`);
             }
             const writeMapPromise = result.map ? fsExtra.writeFile(`${outputPath}.map`, result.map.toString()) : null;
             await Promise.all([
@@ -1022,14 +1130,21 @@ class Program {
                 const typedefPath = outputPath.replace(/\.brs$/i, '.d.bs');
                 await fsExtra.writeFile(typedefPath, typedef);
             }
-            this.plugins.emit('afterFileTranspile', entry);
+            this.plugins.emit('afterFileTranspile', {
+                program: this,
+                file: entry.file,
+                outputPath: entry.outputPath
+            });
         });
         //if there's no bslib file already loaded into the program, copy it to the staging directory
-        if (!this.getFileByPkgPath(bslibAliasedRokuModulesPkgPath) && !this.getFileByPkgPath((0, util_1.standardizePath) `source/bslib.brs`)) {
+        if (!this.getFile(bslibAliasedRokuModulesPkgPath) && !this.getFile(`pkg:/source/bslib.brs`)) {
             promises.push(util_1.util.copyBslibToStaging(stagingFolderPath));
         }
         await Promise.all(promises);
-        this.plugins.emit('afterProgramTranspile', this, entries);
+        this.plugins.emit('afterProgramTranspile', {
+            program: this,
+            entries: entries
+        });
     }
     /**
      * Find a list of files in the program that have a function with the given name (case INsensitive)
@@ -1088,11 +1203,13 @@ class Program {
         return this._manifest;
     }
     dispose() {
-        for (let filePath in this.files) {
-            this.files[filePath].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);
         }
         for (let name in this.scopes) {
-            this.scopes[name].dispose();
+            (_b = this.scopes[name]) === null || _b === void 0 ? void 0 : _b.dispose();
         }
         this.globalScope.dispose();
         this.dependencyGraph.dispose();