brighterscript 1.0.0-alpha.2 → 1.0.0-alpha.22

package/dist/Program.js

@@ -20,10 +20,11 @@ const Manifest_1 = require("./preprocessor/Manifest");
 const vscode_uri_1 = require("vscode-uri");
 const PluginInterface_1 = require("./PluginInterface");
 const reflection_1 = require("./astUtils/reflection");
-const parser_1 = require("./parser");
-const lexer_1 = require("./lexer");
+const Parser_1 = require("./parser/Parser");
+const TokenKind_1 = require("./lexer/TokenKind");
 const BscPlugin_1 = require("./bscPlugin/BscPlugin");
 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 {
@@ -112,7 +113,7 @@ class Program {
     /**
      * Get a copy of the list of files currently loaded in the program
      */
-    getFiles() {
+    getAllFiles() {
         return Object.values(this.files);
     }
     addScope(scope) {
@@ -263,18 +264,20 @@ class Program {
     /**
      * Update internal maps with this file reference
      */
-    setFile(file) {
+    assignFile(file) {
         this.files[file.srcPath.toLowerCase()] = file;
         this.pkgMap[file.pkgPath.toLowerCase()] = file;
+        return file;
     }
     /**
      * Remove this file from internal maps
      */
-    unsetFile(file) {
+    unassignFile(file) {
         delete this.files[file.srcPath.toLowerCase()];
         delete this.pkgMap[file.pkgPath.toLowerCase()];
+        return file;
     }
-    addOrReplaceFile(fileParam, fileContents) {
+    setFile(fileParam, fileContents) {
         assert.ok(fileParam, 'fileParam is required');
         let srcPath;
         let pkgPath;
@@ -282,7 +285,7 @@ class Program {
             //is a pkg path
             if (fileParam.startsWith('pkg:/')) {
                 //srcPath is the pkgPath relative to the rootDir
-                srcPath = util_1.standardizePath `${this.options.rootDir}/${fileParam.substring(5)}`;
+                srcPath = (0, util_1.standardizePath) `${this.options.rootDir}/${fileParam.substring(5)}`;
                 pkgPath = fileParam;
                 //is a srcPath (absolute path to src file location)
             }
@@ -293,17 +296,17 @@ class Program {
                 //is destPath (path relative to rootDir and `pkg:/`)
             }
             else {
-                srcPath = util_1.standardizePath `${this.options.rootDir}/${fileParam}`;
+                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}`;
+            srcPath = (0, util_1.standardizePath) `${fileParam.src}`;
             pkgPath = util_1.util.sanitizePkgPath(fileParam.dest);
         }
         const lowerPkgPath = pkgPath.toLowerCase();
-        return this.logger.time(Logger_1.LogLevel.debug, ['Program.addOrReplaceFile()', chalk_1.default.green(srcPath)], () => {
+        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
@@ -318,47 +321,49 @@ class Program {
                 source: fileContents
             };
             if (fileExtension === '.brs' || fileExtension === '.bs') {
-                let brsFile = new BrsFile_1.BrsFile(srcPath, pkgPath, this);
+                //add the file to the program
+                const brsFile = this.assignFile(new BrsFile_1.BrsFile(srcPath, pkgPath, this));
                 //add file to the `source` dependency list
                 if (brsFile.pkgPath.startsWith('pkg:/source/')) {
                     this.createSourceScope();
                     this.dependencyGraph.addDependency('scope:source', brsFile.dependencyGraphKey);
                 }
                 //add the file to the program
-                this.setFile(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);
                 });
-                file = brsFile;
-                brsFile.attachDependencyGraph(this.dependencyGraph);
+                //notify plugins that this file has finished parsing
                 this.plugins.emit('afterFileParse', {
                     program: this,
                     file: 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)
                 lowerPkgPath.startsWith('pkg:/components/')) {
-                let xmlFile = new XmlFile_1.XmlFile(srcPath, pkgPath, this);
-                this.setFile(xmlFile);
                 //add the file to the program
+                const xmlFile = this.assignFile(new XmlFile_1.XmlFile(srcPath, pkgPath, this));
                 this.plugins.emit('beforeFileParse', beforeFileParseEvent);
                 this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
                     xmlFile.parse(beforeFileParseEvent.source);
                 });
+                //notify plugins that this file has finished parsing
+                this.plugins.emit('afterFileParse', {
+                    program: this,
+                    file: xmlFile
+                });
                 file = xmlFile;
                 //create a new scope for this xml file
                 let scope = new XmlScope_1.XmlScope(xmlFile, this);
                 this.addScope(scope);
                 //register this compoent now that we have parsed it and know its component name
                 this.registerComponent(xmlFile, scope);
-                this.plugins.emit('afterFileParse', {
-                    program: this,
-                    file: xmlFile
-                });
             }
             else {
                 //TODO do we actually need to implement this? Figure out how to handle img paths
@@ -385,18 +390,18 @@ class Program {
     }
     /**
      * Remove a set of files from the program
-     * @param srcPaths
+     * @param filePaths can be an array of srcPath or destPath strings
+     * @param normalizePath should this function repair and standardize the filePaths? Passing false should have a performance boost if you can guarantee your paths are already sanitized
      */
-    removeFiles(srcPaths) {
+    removeFiles(srcPaths, normalizePath = true) {
         for (let srcPath of srcPaths) {
-            this.removeFile(srcPath);
+            this.removeFile(srcPath, normalizePath);
         }
     }
     /**
      * Remove a file from the program
      * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
      * @param 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) {
         this.logger.debug('Program.removeFile()', filePath);
@@ -423,16 +428,18 @@ class Program {
                 });
             }
             //remove the file from the program
-            this.unsetFile(file);
+            this.unassignFile(file);
             this.dependencyGraph.remove(file.dependencyGraphKey);
             //if this is a pkg:/source file, notify the `source` scope that it has changed
             if (file.pkgPath.startsWith('pkg:/source/')) {
                 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);
             }
+            //dispose file
+            file === null || file === void 0 ? void 0 : file.dispose();
             this.plugins.emit('afterFileDispose', {
                 program: this,
                 file: file
@@ -483,6 +490,11 @@ class Program {
                         program: this,
                         file: file
                     });
+                    //emit an event to allow plugins to contribute to the file validation process
+                    this.plugins.emit('onFileValidate', {
+                        program: this,
+                        file: file
+                    });
                     //call file.validate() IF the file has that function defined
                     (_a = file.validate) === null || _a === void 0 ? void 0 : _a.call(file);
                     file.isValidated = true;
@@ -524,7 +536,7 @@ class Program {
         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)) {
+            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)) {
@@ -562,6 +574,16 @@ class Program {
         }
         return false;
     }
+    /**
+     * Get the files for a list of filePaths
+     * @param filePaths can be an array of srcPath or a destPath strings
+     * @param normalizePath should this function repair and standardize the paths? Passing false should have a performance boost if you can guarantee your paths are already sanitized
+     */
+    getFiles(filePaths, normalizePath = true) {
+        return filePaths
+            .map(filePath => this.getFile(filePath, normalizePath))
+            .filter(file => file !== undefined);
+    }
     /**
      * Get the file at the given path
      * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
@@ -592,6 +614,17 @@ class Program {
         }
         return result;
     }
+    /**
+     * Get the first found scope for a file.
+     */
+    getFirstScopeForFile(file) {
+        for (let key in this.scopes) {
+            let scope = this.scopes[key];
+            if (scope.hasFile(file)) {
+                return scope;
+            }
+        }
+    }
     getStatementsByName(name, originFile, namespaceName) {
         var _a, _b;
         let results = new Map();
@@ -601,7 +634,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);
@@ -624,17 +657,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);
@@ -660,9 +696,9 @@ class Program {
             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, TokenKind_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));
@@ -676,7 +712,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) {
@@ -695,7 +736,7 @@ class Program {
         const result = [];
         for (const key in this.files) {
             const file = this.files[key];
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 result.push(...file.getWorkspaceSymbols());
             }
         }
@@ -711,7 +752,7 @@ class Program {
         if (!file) {
             return [];
         }
-        if (reflection_1.isBrsFile(file)) {
+        if ((0, reflection_1.isBrsFile)(file)) {
             return file.getDefinition(position);
         }
         else {
@@ -732,7 +773,8 @@ class Program {
         if (!file) {
             return null;
         }
-        return Promise.resolve(file.getHover(position));
+        const hover = file.getHover(position);
+        return Promise.resolve(hover);
     }
     /**
      * Compute code actions for the given file and range
@@ -761,10 +803,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();
@@ -787,12 +845,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)) {
-                        let classes = scope.getClassHierarchy(myClass.item.getName(parser_1.ParseMode.BrighterScript).toLowerCase());
+                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.isMethodStatement)(i.item))) {
                             let sigHelp = statement.file.getSignatureHelpForStatement(statement.item);
                             if (sigHelp && !results.has[sigHelp.key]) {
                                 results.set(sigHelp.key, sigHelp);
@@ -800,6 +860,7 @@ class Program {
                             }
                         }
                     }
+                    scope.unlinkSymbolTable();
                 }
             }
             if (identifierInfo.dotPart) {
@@ -821,7 +882,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);
@@ -860,13 +921,13 @@ class Program {
         if (!itemCounts.isArgStartFound) {
             //try to get sig help based on the name
             index = position.character;
-            let currentToken = file.getTokenAt(position);
-            if (currentToken && currentToken.kind !== lexer_1.TokenKind.Comment) {
-                name = file.getPartialVariableName(currentToken, [lexer_1.TokenKind.New]);
+            let currentToken = file.parser.getTokenAt(position);
+            if (currentToken && currentToken.kind !== TokenKind_1.TokenKind.Comment) {
+                name = file.getPartialVariableName(currentToken, [TokenKind_1.TokenKind.New]);
                 if (!name) {
                     //try the previous token, incase we're on a bracket
-                    currentToken = file.getPreviousToken(currentToken);
-                    name = file.getPartialVariableName(currentToken, [lexer_1.TokenKind.New]);
+                    currentToken = file.parser.getPreviousToken(currentToken);
+                    name = file.getPartialVariableName(currentToken, [TokenKind_1.TokenKind.New]);
                 }
                 if (name === null || name === void 0 ? void 0 : name.indexOf('.')) {
                     let parts = name.split('.');
@@ -1034,23 +1095,63 @@ 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
+     * @param srcPath can be a srcPath or a destPath
      */
     getTranspiledFileContents(srcPath) {
-        let file = this.getFile(srcPath);
-        let result = file.transpile();
-        return Object.assign(Object.assign({}, result), { srcPath: file.srcPath, pkgPath: file.pkgPath });
+        return this._getTranspiledFileContents(this.getFile(srcPath));
+    }
+    /**
+     * Internal function used to transpile files.
+     * This does not write anything to the file system
+     */
+    _getTranspiledFileContents(file, outputPath) {
+        const editor = new AstEditor_1.AstEditor();
+        this.plugins.emit('beforeFileTranspile', {
+            program: this,
+            file: file,
+            outputPath: outputPath,
+            editor: editor
+        });
+        //if we have any edits, assume the file needs to be transpiled
+        if (editor.hasChanges) {
+            //use the `editor` because it'll track the previous value for us and revert later on
+            editor.setProperty(file, 'needsTranspiled', true);
+        }
+        //transpile the file
+        const result = file.transpile();
+        //generate the typedef if enabled
+        let typedef;
+        if ((0, reflection_1.isBrsFile)(file) && this.options.emitDefinitions) {
+            typedef = file.getTypedef();
+        }
+        const event = {
+            program: this,
+            file: file,
+            outputPath: outputPath,
+            editor: editor,
+            code: result.code,
+            map: result.map,
+            typedef: typedef
+        };
+        this.plugins.emit('afterFileTranspile', event);
+        //undo all `editor` edits that may have been applied to this file.
+        editor.undoAll();
+        return {
+            srcPath: file.srcPath,
+            pkgPath: file.pkgPath,
+            code: event.code,
+            map: event.map,
+            typedef: event.typedef
+        };
     }
     async transpile(fileEntries, stagingFolderPath) {
         // map fileEntries using their path as key to avoid excessive "find()" operations
         const mappedFileEntries = fileEntries.reduce((collection, entry) => {
-            collection[util_1.standardizePath `${entry.src}`] = entry;
+            collection[(0, util_1.standardizePath) `${entry.src}`] = entry;
             return collection;
         }, {});
-        const entries = [];
-        for (const key in this.files) {
-            const file = this.files[key];
-            let filePathObj = mappedFileEntries[util_1.standardizePath `${file.srcPath}`];
+        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 = {
@@ -1066,58 +1167,74 @@ class Program {
                 //change any .bs file extension to .brs
                 .replace(/\.bs$/gi, '.brs');
             //prepend the staging folder path
-            outputPath = util_1.standardizePath `${stagingFolderPath}/${outputPath}`;
-            entries.push({
-                file: file,
-                outputPath: outputPath
-            });
-        }
-        this.plugins.emit('beforeProgramTranspile', {
-            program: this,
-            entries: entries
-        });
-        const promises = entries.map(async (entry) => {
+            outputPath = (0, util_1.standardizePath) `${stagingFolderPath}/${outputPath}`;
+            return outputPath;
+        };
+        const processedFiles = new Set();
+        const transpileFile = async (file, outputPath) => {
+            //mark this file as processed so we don't do it again
+            processedFiles.add(file);
             //skip transpiling typedef files
-            if (reflection_1.isBrsFile(entry.file) && entry.file.isTypedef) {
+            if ((0, reflection_1.isBrsFile)(file) && file.isTypedef) {
                 return;
             }
-            this.plugins.emit('beforeFileTranspile', {
-                program: this,
-                file: entry.file,
-                outputPath: entry.outputPath
-            });
-            const { file, outputPath } = entry;
-            const result = file.transpile();
+            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 = result.map ? fsExtra.writeFile(`${outputPath}.map`, result.map.toString()) : null;
+            const writeMapPromise = fileTranspileResult.map ? fsExtra.writeFile(`${outputPath}.map`, fileTranspileResult.map.toString()) : null;
             await Promise.all([
-                fsExtra.writeFile(outputPath, result.code),
+                fsExtra.writeFile(outputPath, fileTranspileResult.code),
                 writeMapPromise
             ]);
-            if (reflection_1.isBrsFile(file) && this.options.emitDefinitions) {
-                const typedef = file.getTypedef();
+            if (fileTranspileResult.typedef) {
                 const typedefPath = outputPath.replace(/\.brs$/i, '.d.bs');
-                await fsExtra.writeFile(typedefPath, typedef);
+                await fsExtra.writeFile(typedefPath, fileTranspileResult.typedef);
             }
-            this.plugins.emit('afterFileTranspile', {
-                program: this,
-                file: entry.file,
-                outputPath: entry.outputPath
-            });
+        };
+        const entries = Object.values(this.files).map(file => {
+            return {
+                file: file,
+                outputPath: getOutputPath(file)
+            };
+        });
+        const astEditor = new AstEditor_1.AstEditor();
+        this.plugins.emit('beforeProgramTranspile', {
+            program: this,
+            entries: entries,
+            editor: astEditor
+        });
+        let promises = entries.map(async (entry) => {
+            return transpileFile(entry.file, 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(`pkg:/source/bslib.brs`)) {
+        if (!this.getFile(bslibAliasedRokuModulesPkgPath) && !this.getFile((0, util_1.standardizePath) `pkg:/source/bslib.brs`)) {
             promises.push(util_1.util.copyBslibToStaging(stagingFolderPath));
         }
         await Promise.all(promises);
+        //transpile any new files that plugins added since the start of this transpile process
+        do {
+            promises = [];
+            for (const key in this.files) {
+                const file = this.files[key];
+                //this is a new file
+                if (!processedFiles.has(file)) {
+                    promises.push(transpileFile(file, getOutputPath(file)));
+                }
+            }
+            if (promises.length > 0) {
+                this.logger.info(`Transpiling ${promises.length} new files`);
+                await Promise.all(promises);
+            }
+        } while (promises.length > 0);
         this.plugins.emit('afterProgramTranspile', {
             program: this,
-            entries: entries
+            entries: entries,
+            editor: astEditor
         });
+        astEditor.undoAll();
     }
     /**
      * Find a list of files in the program that have a function with the given name (case INsensitive)
@@ -1127,7 +1244,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) {
@@ -1138,14 +1255,14 @@ class Program {
         return files;
     }
     /**
-     * Find a list of files in the program that have a function with the given name (case INsensitive)
+     * Find a list of files in the program that have a class with the given name (case INsensitive)
      */
     findFilesForClass(className) {
         const files = [];
         const lowerClassName = className.toLowerCase();
         //find every file with this class defined
         for (const file of Object.values(this.files)) {
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 //TODO handle namespace-relative classes
                 //if the file has a function with this name
                 if (file.parser.references.classStatementLookup.get(lowerClassName) !== undefined) {
@@ -1167,7 +1284,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();