brighterscript 1.0.0-alpha.1 → 1.0.0-alpha.13

package/dist/Program.js

@@ -23,9 +23,10 @@ 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 = util_1.standardizePath `source/roku_modules/rokucommunity_bslib/bslib.brs`;
-const bslibAliasedRokuModulesPkgPath = util_1.standardizePath `source/roku_modules/bslib/bslib.brs`;
+const roku_deploy_1 = require("roku-deploy");
+const AstEditor_1 = require("./astUtils/AstEditor");
+const bslibNonAliasedRokuModulesPkgPath = `pkg:/source/roku_modules/rokucommunity_bslib/bslib.brs`;
+const bslibAliasedRokuModulesPkgPath = `pkg:/source/roku_modules/bslib/bslib.brs`;
 class Program {
     constructor(
     /**
@@ -47,10 +48,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 +90,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,6 +110,12 @@ 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', {
@@ -181,8 +191,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);
@@ -222,13 +232,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 = 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
@@ -238,9 +245,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 = util_1.standardizePath `${scopeName}`;
         let key = Object.keys(this.scopes).find(x => x.toLowerCase() === scopeName.toLowerCase());
         return this.scopes[key];
     }
@@ -257,21 +261,52 @@ 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 = util_1.standardizePath `${this.options.rootDir}/${fileParam}`;
-            pkgPath = 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 = util_1.standardizePath `${fileParam.src}`;
-            pkgPath = util_1.standardizePath `${fileParam.dest}`;
+            srcPath = (0, util_1.standardizePath) `${fileParam.src}`;
+            pkgPath = util_1.util.sanitizePkgPath(fileParam.dest);
         }
-        return 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);
@@ -280,19 +315,18 @@ class Program {
             let file;
             const beforeFileParseEvent = {
                 program: this,
-                pathAbsolute: srcPath,
+                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;
+                this.assignFile(brsFile);
                 this.plugins.emit('beforeFileParse', beforeFileParseEvent);
                 this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
                     brsFile.parse(beforeFileParseEvent.source);
@@ -308,11 +342,10 @@ class Program {
             //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;
                 this.plugins.emit('beforeFileParse', beforeFileParseEvent);
                 this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
                     xmlFile.parse(beforeFileParseEvent.source);
@@ -330,8 +363,8 @@ class Program {
             }
             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;
@@ -351,55 +384,24 @@ 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 = 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', {
                 program: this,
@@ -422,15 +424,14 @@ class Program {
                 });
             }
             //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 (reflection_1.isXmlFile(file)) {
+            if ((0, reflection_1.isXmlFile)(file)) {
                 this.unregisterComponent(file);
             }
             this.plugins.emit('afterFileDispose', {
@@ -439,6 +440,25 @@ class Program {
             });
         }
     }
+    /**
+     * 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);
+            }
+        }
+    }
     /**
      * Traverse the entire project, and validate all scopes
      * @param force - if true, then all scopes are force to validate, even if they aren't marked as dirty
@@ -500,28 +520,31 @@ class Program {
      * 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 (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'
                             };
                         }) }));
@@ -542,11 +565,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 = 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
@@ -571,7 +602,7 @@ class Program {
         //look through all files in scope for matches
         for (const scope of this.getScopesForFile(originFile)) {
             for (const file of scope.getAllFiles()) {
-                if (reflection_1.isXmlFile(file) || filesSearched.has(file)) {
+                if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
                     continue;
                 }
                 filesSearched.add(file);
@@ -594,17 +625,20 @@ class Program {
         //get all function names for the xml file and parents
         let funcNames = new Set();
         let currentScope = scope;
-        while (reflection_1.isXmlScope(currentScope)) {
-            for (let name of (_b = (_a = currentScope.xmlFile.ast.component.api) === null || _a === void 0 ? void 0 : _a.functions.map((f) => f.name)) !== null && _b !== void 0 ? _b : []) {
-                if (!filterName || name === filterName) {
-                    funcNames.add(name);
+        while ((0, reflection_1.isXmlScope)(currentScope)) {
+            for (let member of (_b = (_a = currentScope.xmlFile.ast.component) === null || _a === void 0 ? void 0 : _a.interfaceMembers) !== null && _b !== void 0 ? _b : []) {
+                if ((0, reflection_1.isSGInterfaceFunction)(member)) {
+                    const name = member.name;
+                    if (!filterName || name === filterName) {
+                        funcNames.add(name);
+                    }
                 }
             }
             currentScope = currentScope.getParentScope();
         }
         //look through all files in scope for matches
         for (const file of scope.getOwnFiles()) {
-            if (reflection_1.isXmlFile(file) || filesSearched.has(file)) {
+            if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
                 continue;
             }
             filesSearched.add(file);
@@ -620,19 +654,19 @@ 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 (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) => reflection_1.isXmlScope(s))) {
+            for (const scope of this.getScopes().filter((s) => (0, reflection_1.isXmlScope)(s))) {
                 let fileLinks = this.getStatementsForXmlFile(scope);
                 for (let fileLink of fileLinks) {
                     result.push(scope.createCompletionFromFunctionStatement(fileLink.item));
@@ -646,7 +680,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) {
@@ -662,25 +701,26 @@ 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 (reflection_1.isBrsFile(file)) {
-                return file.getWorkspaceSymbols();
+            if ((0, reflection_1.isBrsFile)(file)) {
+                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 [];
         }
-        if (reflection_1.isBrsFile(file)) {
+        if ((0, reflection_1.isBrsFile)(file)) {
             return file.getDefinition(position);
         }
         else {
@@ -692,9 +732,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;
         }
@@ -702,10 +745,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)
@@ -726,10 +770,26 @@ class Program {
         }
         return codeActions;
     }
+    /**
+     * Get semantic tokens for the specified file
+     */
+    getSemanticTokens(srcPath) {
+        const file = this.getFile(srcPath);
+        if (file) {
+            const result = [];
+            this.plugins.emit('onGetSemanticTokens', {
+                program: this,
+                file: file,
+                scopes: this.getScopesForFile(file),
+                semanticTokens: result
+            });
+            return result;
+        }
+    }
     getSignatureHelp(filepath, position) {
         var _a;
         let file = this.getFile(filepath);
-        if (!file || !reflection_1.isBrsFile(file)) {
+        if (!file || !(0, reflection_1.isBrsFile)(file)) {
             return [];
         }
         const results = new Map();
@@ -752,12 +812,14 @@ class Program {
             //if m class reference.. then
             //only get statements from the class I am in..
             if (functionExpression) {
-                let myClass = file.getClassFromMReference(position, file.getTokenAt(position), functionExpression);
-                if (myClass) {
-                    for (let scope of this.getScopesForFile(myClass.file)) {
+                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) => reflection_1.isClassMethodStatement(i.item))) {
+                        for (let statement of [...classes].filter((i) => (0, reflection_1.isClassMethodStatement)(i.item))) {
                             let sigHelp = statement.file.getSignatureHelpForStatement(statement.item);
                             if (sigHelp && !results.has[sigHelp.key]) {
                                 results.set(sigHelp.key, sigHelp);
@@ -765,6 +827,7 @@ class Program {
                             }
                         }
                     }
+                    scope.unlinkSymbolTable();
                 }
             }
             if (identifierInfo.dotPart) {
@@ -786,7 +849,7 @@ class Program {
             }
         }
         else if (identifierInfo.statementType === '@.') {
-            for (const scope of this.getScopes().filter((s) => reflection_1.isXmlScope(s))) {
+            for (const scope of this.getScopes().filter((s) => (0, reflection_1.isXmlScope)(s))) {
                 let fileLinks = this.getStatementsForXmlFile(scope, identifierInfo.name);
                 for (let fileLink of fileLinks) {
                     let sigHelp = fileLink.file.getSignatureHelpForStatement(fileLink.item);
@@ -825,12 +888,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('.')) {
@@ -937,9 +1000,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;
         }
@@ -957,8 +1023,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') &&
@@ -966,14 +1032,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,
@@ -982,11 +1046,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
                         }
                     });
@@ -998,76 +1062,84 @@ 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[util_1.standardizePath `${entry.src}`] = entry;
+            collection[(0, util_1.standardizePath) `${entry.src}`] = entry;
             return collection;
         }, {});
-        const entries = Object.values(this.files).map(file => {
-            let filePathObj = mappedFileEntries[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 = util_1.standardizePath `${stagingFolderPath}/${outputPath}`;
-            return {
+            outputPath = (0, util_1.standardizePath) `${stagingFolderPath}/${outputPath}`;
+            entries.push({
                 file: file,
-                outputPath: outputPath
-            };
-        });
+                program: this,
+                outputPath: outputPath,
+                editor: new AstEditor_1.AstEditor()
+            });
+        }
         this.plugins.emit('beforeProgramTranspile', {
             program: this,
             entries: entries
         });
         const promises = entries.map(async (entry) => {
             //skip transpiling typedef files
-            if (reflection_1.isBrsFile(entry.file) && entry.file.isTypedef) {
+            if ((0, reflection_1.isBrsFile)(entry.file) && entry.file.isTypedef) {
                 return;
             }
-            this.plugins.emit('beforeFileTranspile', {
-                program: this,
-                file: entry.file,
-                outputPath: entry.outputPath
-            });
+            this.plugins.emit('beforeFileTranspile', entry);
             const { file, outputPath } = entry;
+            //if we have any edits, assume the file needs to be transpiled
+            if (entry.editor.hasChanges) {
+                //use the `editor` because it'll track the previous value for us and revert later on
+                entry.editor.setProperty(file, 'needsTranspiled', true);
+            }
             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([
                 fsExtra.writeFile(outputPath, result.code),
                 writeMapPromise
             ]);
-            if (reflection_1.isBrsFile(file) && this.options.emitDefinitions) {
+            if ((0, reflection_1.isBrsFile)(file) && this.options.emitDefinitions) {
                 const typedef = file.getTypedef();
                 const typedefPath = outputPath.replace(/\.brs$/i, '.d.bs');
                 await fsExtra.writeFile(typedefPath, typedef);
             }
-            this.plugins.emit('afterFileTranspile', {
-                program: this,
-                file: entry.file,
-                outputPath: entry.outputPath
-            });
+            this.plugins.emit('afterFileTranspile', entry);
+            //undo all `editor` edits that may have been applied to this file.
+            entry.editor.undoAll();
         });
         //if there's no bslib file already loaded into the program, copy it to the staging directory
-        if (!this.getFileByPkgPath(bslibAliasedRokuModulesPkgPath) && !this.getFileByPkgPath(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);
@@ -1084,7 +1156,7 @@ class Program {
         const lowerFunctionName = functionName.toLowerCase();
         //find every file with this function defined
         for (const file of Object.values(this.files)) {
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 //TODO handle namespace-relative function calls
                 //if the file has a function with this name
                 if (file.parser.references.functionStatementLookup.get(lowerFunctionName) !== undefined) {
@@ -1102,7 +1174,7 @@ class Program {
         const lowerClassName = className.toLowerCase();
         //find every file with this class defined
         for (const file of Object.values(this.files)) {
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 //TODO handle namespace-relative classes
                 //if the file has a function with this name
                 if (file.parser.references.classStatementLookup.get(lowerClassName) !== undefined) {
@@ -1124,7 +1196,7 @@ class Program {
             try {
                 //we only load this manifest once, so do it sync to improve speed downstream
                 contents = fsExtra.readFileSync(manifestPath, 'utf-8');
-                this._manifest = Manifest_1.parseManifest(contents);
+                this._manifest = (0, Manifest_1.parseManifest)(contents);
             }
             catch (err) {
                 this._manifest = new Map();
@@ -1133,11 +1205,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();