brighterscript 0.66.0-alpha.6 → 0.66.0-alpha.8

package/dist/files/BrsFile.js

@@ -22,19 +22,15 @@ const visitors_1 = require("../astUtils/visitors");
 const CommentFlagProcessor_1 = require("../CommentFlagProcessor");
 const vscode_uri_1 = require("vscode-uri");
 const SymbolTable_1 = require("../SymbolTable");
+const Editor_1 = require("../astUtils/Editor");
+const AstValidationSegmenter_1 = require("../AstValidationSegmenter");
 /**
  * Holds all details about this file within the scope of the whole program
  */
 class BrsFile {
-    constructor(srcPath, 
-    /**
-     * The full pkg path to this file
-     */
-    pkgPath, program) {
-        var _a, _b;
-        this.srcPath = srcPath;
-        this.pkgPath = pkgPath;
-        this.program = program;
+    constructor(options) {
+        var _a, _b, _c;
+        this.type = 'BrsFile';
         /**
          * The parseMode used for the parser for this file
          */
@@ -51,31 +47,44 @@ class BrsFile {
         this.commentFlags = [];
         this.callables = [];
         this.functionCalls = [];
-        /**
-         * Does this file need to be transpiled?
-         */
-        this.needsTranspiled = false;
         this.scopesByFunc = new Map();
-        this.srcPath = (0, util_1.standardizePath) `${this.srcPath}`;
-        this.pkgPath = (0, util_1.standardizePath) `${this.pkgPath}`;
-        this.dependencyGraphKey = this.pkgPath.toLowerCase();
-        this.extension = util_1.util.getExtension(this.srcPath);
-        //all BrighterScript files need to be transpiled
-        if (((_a = this.extension) === null || _a === void 0 ? void 0 : _a.endsWith('.bs')) || ((_b = program === null || program === void 0 ? void 0 : program.options) === null || _b === void 0 ? void 0 : _b.allowBrighterScriptInBrightScript)) {
-            this.needsTranspiled = true;
-            this.parseMode = Parser_1.ParseMode.BrighterScript;
-        }
-        this.isTypedef = this.extension === '.d.bs';
-        if (!this.isTypedef) {
-            this.typedefKey = util_1.util.getTypedefPath(this.srcPath);
-        }
-        //global file doesn't have a program, so only resolve typedef info if we have a program
-        if (this.program) {
-            this.resolveTypedef();
+        this.validationSegmenter = new AstValidationSegmenter_1.AstValidationSegmenter();
+        if (options) {
+            this.srcPath = (0, util_1.standardizePath) `${options.srcPath}`;
+            this.destPath = (0, util_1.standardizePath) `${options.destPath}`;
+            this.program = options.program;
+            this.extension = util_1.util.getExtension(this.srcPath);
+            if (options.pkgPath) {
+                this.pkgPath = options.pkgPath;
+            }
+            else {
+                //don't rename .d.bs files to .d.brs
+                if (this.extension === '.d.bs') {
+                    this.pkgPath = this.destPath;
+                }
+                else {
+                    this.pkgPath = this.destPath.replace(/\.bs$/i, '.brs');
+                }
+            }
+            //all BrighterScript files need to be transpiled
+            if (((_a = this.extension) === null || _a === void 0 ? void 0 : _a.endsWith('.bs')) || ((_c = (_b = this.program) === null || _b === void 0 ? void 0 : _b.options) === null || _c === void 0 ? void 0 : _c.allowBrighterScriptInBrightScript)) {
+                this.parseMode = Parser_1.ParseMode.BrighterScript;
+            }
+            this.isTypedef = this.extension === '.d.bs';
+            if (!this.isTypedef) {
+                this.typedefKey = util_1.util.getTypedefPath(this.srcPath);
+            }
+            //global file doesn't have a program, so only resolve typedef info if we have a program
+            if (this.program) {
+                this.resolveTypedef();
+            }
         }
     }
+    /**
+     * @deprecated use `.diagnostics` instead
+     */
     getDiagnostics() {
-        return [...this.diagnostics];
+        return this.diagnostics;
     }
     addDiagnostic(diagnostic) {
         if (!diagnostic.file) {
@@ -110,7 +119,7 @@ class BrsFile {
                 if ((0, reflection_1.isImportStatement)(statement) && statement.filePathToken) {
                     result.push({
                         filePathRange: statement.filePathToken.range,
-                        pkgPath: util_1.util.getPkgPathFromTarget(this.pkgPath, statement.filePath),
+                        destPath: util_1.util.getPkgPathFromTarget(this.destPath, statement.filePath),
                         sourceFile: this,
                         text: (_d = statement.filePathToken) === null || _d === void 0 ? void 0 : _d.text
                     });
@@ -120,11 +129,26 @@ class BrsFile {
         })) !== null && _b !== void 0 ? _b : [];
         return result;
     }
+    /**
+     * Does this file need to be transpiled?
+     * @deprecated use the `.editor` property to push changes to the file, which will force transpilation
+     */
+    get needsTranspiled() {
+        var _a, _b, _c, _d;
+        if (this._needsTranspiled !== undefined) {
+            return this._needsTranspiled;
+        }
+        return !!(((_a = this.extension) === null || _a === void 0 ? void 0 : _a.endsWith('.bs')) || ((_c = (_b = this.program) === null || _b === void 0 ? void 0 : _b.options) === null || _c === void 0 ? void 0 : _c.allowBrighterScriptInBrightScript) || ((_d = this.editor) === null || _d === void 0 ? void 0 : _d.hasChanges));
+    }
+    set needsTranspiled(value) {
+        this._needsTranspiled = value;
+    }
     /**
      * The AST for this file
      */
     get ast() {
-        return this.parser.ast;
+        var _a;
+        return (_a = this.parser) === null || _a === void 0 ? void 0 : _a.ast;
     }
     /**
      * Get the token at the specified position
@@ -178,23 +202,25 @@ class BrsFile {
         this.typedefFile = this.program.getFile(this.typedefKey);
         this.hasTypedef = !!this.typedefFile;
     }
+    onDependenciesChanged() {
+        this.resolveTypedef();
+    }
     /**
      * Attach the file to the dependency graph so it can monitor changes.
      * Also notify the dependency graph of our current dependencies so other dependents can be notified.
+     * @deprecated this does nothing. This functionality is now handled by the file api and will be deleted in v1
      */
-    attachDependencyGraph(dependencyGraph) {
-        var _a;
-        (_a = this.unsubscribeFromDependencyGraph) === null || _a === void 0 ? void 0 : _a.call(this);
-        //event that fires anytime a dependency changes
-        this.unsubscribeFromDependencyGraph = dependencyGraph.onchange(this.dependencyGraphKey, () => {
-            this.resolveTypedef();
-        });
-        const dependencies = this.ownScriptImports.filter(x => !!x.pkgPath).map(x => x.pkgPath.toLowerCase());
+    attachDependencyGraph(dependencyGraph) { }
+    /**
+     * The list of files that this file depends on
+     */
+    get dependencies() {
+        const result = this.ownScriptImports.filter(x => !!x.destPath).map(x => x.destPath.toLowerCase());
         //if this is a .brs file, watch for typedef changes
         if (this.extension === '.brs') {
-            dependencies.push(util_1.util.getTypedefPath(this.pkgPath));
+            result.push(util_1.util.getTypedefPath(this.destPath));
         }
-        dependencyGraph.addOrReplace(this.dependencyGraphKey, dependencies);
+        return result;
     }
     /**
      * Calculate the AST for this file
@@ -864,7 +890,7 @@ class BrsFile {
                 results.push(util_1.util.createLocation(vscode_uri_1.URI.file(constant.file.srcPath).toString(), constant.item.tokens.name.range));
                 return results;
             }
-            if ((0, reflection_1.isDottedGetExpression)(expression)) {
+            if ((0, reflection_1.isDottedGetExpression)(expression) || (0, reflection_1.isVariableExpression)(expression)) {
                 const enumLink = scope.getEnumFileLink(fullName, containingNamespace);
                 if (enumLink) {
                     results.push(util_1.util.createLocation(vscode_uri_1.URI.file(enumLink.file.srcPath).toString(), enumLink.item.tokens.name.range));
@@ -875,6 +901,16 @@ class BrsFile {
                     results.push(util_1.util.createLocation(vscode_uri_1.URI.file(enumMemberLink.file.srcPath).toString(), enumMemberLink.item.tokens.name.range));
                     return results;
                 }
+                const interfaceFileLink = scope.getInterfaceFileLink(fullName, containingNamespace);
+                if (interfaceFileLink) {
+                    results.push(util_1.util.createLocation(vscode_uri_1.URI.file(interfaceFileLink.file.srcPath).toString(), interfaceFileLink.item.tokens.name.range));
+                    return results;
+                }
+                const classFileLink = scope.getClassFileLink(fullName, containingNamespace);
+                if (classFileLink) {
+                    results.push(util_1.util.createLocation(vscode_uri_1.URI.file(classFileLink.file.srcPath).toString(), classFileLink.item.name.range));
+                    return results;
+                }
             }
         }
         let textToSearchFor = token.text.toLowerCase();
@@ -934,28 +970,27 @@ class BrsFile {
         //look through all files in scope for matches
         for (const scope of scopesForFile) {
             for (const file of scope.getAllFiles()) {
-                if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
-                    continue;
-                }
-                filesSearched.add(file);
-                if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind) === TokenKind_1.TokenKind.Dot && file.parseMode === Parser_1.ParseMode.BrighterScript) {
-                    results.push(...this.getClassMemberDefinitions(textToSearchFor, file));
-                    const namespaceDefinition = this.getNamespaceDefinitions(token, file);
-                    if (namespaceDefinition) {
-                        results.push(namespaceDefinition);
+                if ((0, reflection_1.isBrsFile)(file) && !filesSearched.has(file)) {
+                    filesSearched.add(file);
+                    if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind) === TokenKind_1.TokenKind.Dot && file.parseMode === Parser_1.ParseMode.BrighterScript) {
+                        results.push(...this.getClassMemberDefinitions(textToSearchFor, file));
+                        const namespaceDefinition = this.getNamespaceDefinitions(token, file);
+                        if (namespaceDefinition) {
+                            results.push(namespaceDefinition);
+                        }
                     }
+                    const statementHandler = (statement) => {
+                        if (statement.getName(this.parseMode).toLowerCase() === textToSearchFor) {
+                            const uri = util_1.util.pathToUri(file.srcPath);
+                            results.push(util_1.util.createLocation(uri, statement.range));
+                        }
+                    };
+                    file.parser.ast.walk((0, visitors_1.createVisitor)({
+                        FunctionStatement: statementHandler
+                    }), {
+                        walkMode: visitors_1.WalkMode.visitStatements
+                    });
                 }
-                const statementHandler = (statement) => {
-                    if (statement.getName(this.parseMode).toLowerCase() === textToSearchFor) {
-                        const uri = util_1.util.pathToUri(file.srcPath);
-                        results.push(util_1.util.createLocation(uri, statement.range));
-                    }
-                };
-                file.parser.ast.walk((0, visitors_1.createVisitor)({
-                    FunctionStatement: statementHandler
-                }), {
-                    walkMode: visitors_1.WalkMode.visitStatements
-                });
             }
         }
         return results;
@@ -1017,28 +1052,47 @@ class BrsFile {
         for (const scope of scopes) {
             const processedFiles = new Set();
             for (const file of scope.getAllFiles()) {
-                if ((0, reflection_1.isXmlFile)(file) || processedFiles.has(file)) {
-                    continue;
-                }
-                processedFiles.add(file);
-                file.ast.walk((0, visitors_1.createVisitor)({
-                    VariableExpression: (e) => {
-                        if (e.name.text.toLowerCase() === searchFor) {
-                            locations.push(util_1.util.createLocation(util_1.util.pathToUri(file.srcPath), e.range));
+                if ((0, reflection_1.isBrsFile)(file) && !processedFiles.has(file)) {
+                    processedFiles.add(file);
+                    file.ast.walk((0, visitors_1.createVisitor)({
+                        VariableExpression: (e) => {
+                            if (e.name.text.toLowerCase() === searchFor) {
+                                locations.push(util_1.util.createLocation(util_1.util.pathToUri(file.srcPath), e.range));
+                            }
                         }
-                    }
-                }), {
-                    walkMode: visitors_1.WalkMode.visitExpressionsRecursive
-                });
+                    }), {
+                        walkMode: visitors_1.WalkMode.visitExpressionsRecursive
+                    });
+                }
             }
         }
         return locations;
     }
+    /**
+     * Generate the code, map, and typedef for this file
+     */
+    serialize() {
+        const result = {};
+        const transpiled = this.transpile();
+        if (typeof transpiled.code === 'string') {
+            result.code = transpiled.code;
+        }
+        if (transpiled.map) {
+            result.map = transpiled.map.toString();
+        }
+        //generate the typedef (if this is not a typedef itself, and if enabled)
+        if (!this.isTypedef && this.program.options.emitDefinitions) {
+            result.typedef = this.getTypedef();
+        }
+        return result;
+    }
     /**
      * Convert the brightscript/brighterscript source code into valid brightscript
      */
     transpile() {
+        var _a;
         const state = new BrsTranspileState_1.BrsTranspileState(this);
+        state.editor = (_a = this.editor) !== null && _a !== void 0 ? _a : new Editor_1.Editor();
         let transpileResult;
         if (this.needsTranspiled) {
             transpileResult = new source_map_1.SourceNode(null, null, state.srcPath, this.ast.transpile(state));
@@ -1051,8 +1105,11 @@ class BrsFile {
             //simple SourceNode wrapping the entire file to simplify the logic below
             transpileResult = new source_map_1.SourceNode(null, null, state.srcPath, this.fileContents);
         }
-        //undo any AST edits that the transpile cycle has made
-        state.editor.undoAll();
+        //if we created an editor for this flow, undo the edits now
+        if (!this.editor) {
+            //undo any AST edits that the transpile cycle has made
+            state.editor.undoAll();
+        }
         if (this.program.options.sourceMap) {
             return new source_map_1.SourceNode(null, null, null, [
                 transpileResult,
@@ -1067,6 +1124,201 @@ class BrsFile {
             };
         }
     }
+    processSymbolInformation() {
+        this.validationSegmenter.processTree(this.ast);
+        this.program.addFileSymbolInfo(this);
+    }
+    getValidationSegments(changedSymbols) {
+        const segments = this.validationSegmenter.getSegments(changedSymbols);
+        return segments;
+    }
+    get requiredSymbols() {
+        return this.cache.getOrAdd(`requiredSymbols`, () => {
+            var _a;
+            const allNeededSymbolSets = this.validationSegmenter.unresolvedSegmentsSymbols.values();
+            const requiredSymbols = [];
+            const addedSymbols = new Map();
+            addedSymbols.set(SymbolTable_1.SymbolTypeFlag.runtime, new Set());
+            addedSymbols.set(SymbolTable_1.SymbolTypeFlag.typetime, new Set());
+            for (const setOfSymbols of allNeededSymbolSets) {
+                for (const symbol of setOfSymbols) {
+                    const fullSymbolKey = symbol.typeChain.map(tce => tce.name).join('.').toLowerCase();
+                    if ((_a = this.providedSymbols.symbolMap.get(symbol.flags)) === null || _a === void 0 ? void 0 : _a.has(fullSymbolKey)) {
+                        // this catches namespaced things
+                        continue;
+                    }
+                    if (!addedSymbols.get(symbol.flags).has(fullSymbolKey)) {
+                        requiredSymbols.push(symbol);
+                        addedSymbols.get(symbol.flags).add(fullSymbolKey);
+                    }
+                }
+            }
+            return requiredSymbols;
+        });
+    }
+    get providedSymbols() {
+        var _a;
+        return (_a = this.cache) === null || _a === void 0 ? void 0 : _a.getOrAdd(`providedSymbols`, () => {
+            return this.getProvidedSymbols();
+        });
+    }
+    getProvidedSymbols() {
+        var _a, _b;
+        const symbolMap = new Map();
+        const runTimeSymbolMap = new Map();
+        const typeTimeSymbolMap = new Map();
+        const tablesToGetSymbolsFrom = [{
+                table: this.parser.symbolTable
+            }];
+        for (const namespaceStatement of this.parser.references.namespaceStatements) {
+            tablesToGetSymbolsFrom.push({
+                table: namespaceStatement.body.getSymbolTable(),
+                namePrefixLower: namespaceStatement.getName(Parser_1.ParseMode.BrighterScript).toLowerCase()
+            });
+        }
+        for (const symbolTable of tablesToGetSymbolsFrom) {
+            const runTimeSymbols = symbolTable.table.getOwnSymbols(SymbolTable_1.SymbolTypeFlag.runtime);
+            const typeTimeSymbols = symbolTable.table.getOwnSymbols(SymbolTable_1.SymbolTypeFlag.typetime);
+            for (const symbol of runTimeSymbols) {
+                if (!(0, reflection_1.isAnyReferenceType)(symbol.type)) {
+                    const symbolNameLower = symbolTable.namePrefixLower
+                        ? `${symbolTable.namePrefixLower}.${symbol.name.toLowerCase()}`
+                        : symbol.name.toLowerCase();
+                    runTimeSymbolMap.set(symbolNameLower, symbol);
+                }
+            }
+            for (const symbol of typeTimeSymbols) {
+                if (!(0, reflection_1.isAnyReferenceType)(symbol.type)) {
+                    const symbolNameLower = symbolTable.namePrefixLower
+                        ? `${symbolTable.namePrefixLower}.${symbol.name.toLowerCase()}`
+                        : symbol.name.toLowerCase();
+                    typeTimeSymbolMap.set(symbolNameLower, symbol);
+                }
+            }
+        }
+        symbolMap.set(SymbolTable_1.SymbolTypeFlag.runtime, runTimeSymbolMap);
+        symbolMap.set(SymbolTable_1.SymbolTypeFlag.typetime, typeTimeSymbolMap);
+        const changes = new Map();
+        changes.set(SymbolTable_1.SymbolTypeFlag.runtime, new Set());
+        changes.set(SymbolTable_1.SymbolTypeFlag.typetime, new Set());
+        const previouslyProvidedSymbols = (_a = this.program.getFileSymbolInfo(this)) === null || _a === void 0 ? void 0 : _a.provides.symbolMap;
+        const previousSymbolsChecked = new Map();
+        previousSymbolsChecked.set(SymbolTable_1.SymbolTypeFlag.runtime, new Set());
+        previousSymbolsChecked.set(SymbolTable_1.SymbolTypeFlag.typetime, new Set());
+        for (const flag of [SymbolTable_1.SymbolTypeFlag.runtime, SymbolTable_1.SymbolTypeFlag.typetime]) {
+            const newSymbolMapForFlag = symbolMap.get(flag);
+            const oldSymbolMapForFlag = previouslyProvidedSymbols === null || previouslyProvidedSymbols === void 0 ? void 0 : previouslyProvidedSymbols.get(flag);
+            const previousSymbolsCheckedForFlag = previousSymbolsChecked.get(flag);
+            const changesForFlag = changes.get(flag);
+            if (!oldSymbolMapForFlag) {
+                for (const key of newSymbolMapForFlag.keys()) {
+                    changesForFlag.add(key);
+                }
+                continue;
+            }
+            for (const [symbolKey, symbol] of newSymbolMapForFlag) {
+                const symbolType = symbol.type;
+                const previousType = (_b = oldSymbolMapForFlag === null || oldSymbolMapForFlag === void 0 ? void 0 : oldSymbolMapForFlag.get(symbolKey)) === null || _b === void 0 ? void 0 : _b.type;
+                previousSymbolsCheckedForFlag.add(symbolKey);
+                if (!previousType) {
+                    changesForFlag.add(symbolKey);
+                    continue;
+                }
+                const data = {};
+                if (!symbolType.isEqual(previousType, data)) {
+                    changesForFlag.add(symbolKey);
+                }
+            }
+            for (const [symbolKey] of previouslyProvidedSymbols.get(flag)) {
+                if (!previousSymbolsCheckedForFlag.has(symbolKey)) {
+                    changesForFlag.add(symbolKey);
+                }
+            }
+        }
+        return {
+            symbolMap: symbolMap,
+            changes: changes
+        };
+    }
+    markSegmentAsValidated(node) {
+        this.validationSegmenter.markSegmentAsValidated(node);
+    }
+    getNamespaceLookupObject() {
+        if (!this.isValidated) {
+            return this.buildNamespaceLookup();
+        }
+        return this.cache.getOrAdd(`namespaceLookup`, () => {
+            const nsLookup = this.buildNamespaceLookup();
+            return nsLookup;
+        });
+    }
+    buildNamespaceLookup() {
+        const namespaceLookup = new Map();
+        for (let namespaceStatement of this.parser.references.namespaceStatements) {
+            let nameParts = namespaceStatement.getNameParts();
+            let loopName = null;
+            let lowerLoopName = null;
+            let parentNameLower = null;
+            //ensure each namespace section is represented in the results
+            //(so if the namespace name is A.B.C, this will make an entry for "A", an entry for "A.B", and an entry for "A.B.C"
+            for (let i = 0; i < nameParts.length; i++) {
+                let part = nameParts[i];
+                let lowerPartName = part.text.toLowerCase();
+                if (i === 0) {
+                    loopName = part.text;
+                    lowerLoopName = lowerPartName;
+                }
+                else {
+                    parentNameLower = lowerLoopName;
+                    loopName += '.' + part.text;
+                    lowerLoopName += '.' + lowerPartName;
+                }
+                if (!namespaceLookup.has(lowerLoopName)) {
+                    namespaceLookup.set(lowerLoopName, {
+                        isTopLevel: i === 0,
+                        file: this,
+                        fullName: loopName,
+                        fullNameLower: lowerLoopName,
+                        parentNameLower: parentNameLower,
+                        nameParts: nameParts.slice(0, i),
+                        nameRange: namespaceStatement.nameExpression.range,
+                        lastPartName: part.text,
+                        lastPartNameLower: lowerPartName,
+                        functionStatements: new Map(),
+                        namespaceStatements: [],
+                        namespaces: new Map(),
+                        classStatements: new Map(),
+                        enumStatements: new Map(),
+                        constStatements: new Map(),
+                        statements: [],
+                        // the aggregate symbol table should have no parent. It should include just the symbols of the namespace.
+                        symbolTable: new SymbolTable_1.SymbolTable(`Namespace Aggregate: '${loopName}'`)
+                    });
+                }
+            }
+            let ns = namespaceLookup.get(lowerLoopName);
+            ns.namespaceStatements.push(namespaceStatement);
+            ns.statements.push(...namespaceStatement.body.statements);
+            for (let statement of namespaceStatement.body.statements) {
+                if ((0, reflection_1.isClassStatement)(statement) && statement.name) {
+                    ns.classStatements.set(statement.name.text.toLowerCase(), statement);
+                }
+                else if ((0, reflection_1.isFunctionStatement)(statement) && statement.name) {
+                    ns.functionStatements.set(statement.name.text.toLowerCase(), statement);
+                }
+                else if ((0, reflection_1.isEnumStatement)(statement) && statement.fullName) {
+                    ns.enumStatements.set(statement.fullName.toLowerCase(), statement);
+                }
+                else if ((0, reflection_1.isConstStatement)(statement) && statement.fullName) {
+                    ns.constStatements.set(statement.fullName.toLowerCase(), statement);
+                }
+            }
+            // Merges all the symbol tables of the namespace statements into the new symbol table created above.
+            // Set those symbol tables to have this new merged table as a parent
+            ns.symbolTable.mergeSymbolTable(namespaceStatement.body.getSymbolTable());
+        }
+        return namespaceLookup;
+    }
     getTypedef() {
         const state = new BrsTranspileState_1.BrsTranspileState(this);
         const typedef = this.ast.getTypedef(state);
@@ -1074,10 +1326,8 @@ class BrsFile {
         return programNode.toString();
     }
     dispose() {
-        var _a, _b;
+        var _a;
         (_a = this._parser) === null || _a === void 0 ? void 0 : _a.dispose();
-        //unsubscribe from any DependencyGraph subscriptions
-        (_b = this.unsubscribeFromDependencyGraph) === null || _b === void 0 ? void 0 : _b.call(this);
         //deleting these properties result in lower memory usage (garbage collection is magic!)
         delete this.fileContents;
         delete this._parser;