brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/bscPlugin/completions/CompletionsProcessor.js

@@ -0,0 +1,633 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeTypeCompletions = exports.KeywordCompletions = exports.CompletionsProcessor = void 0;
+const reflection_1 = require("../../astUtils/reflection");
+const TokenKind_1 = require("../../lexer/TokenKind");
+const util_1 = require("../../util");
+const Parser_1 = require("../../parser/Parser");
+const vscode_languageserver_1 = require("vscode-languageserver");
+const BooleanType_1 = require("../../types/BooleanType");
+const InvalidType_1 = require("../../types/InvalidType");
+const creators_1 = require("../../astUtils/creators");
+const Logger_1 = require("../../Logger");
+const SCOPES_FOR_COMPLETION = 3;
+class CompletionsProcessor {
+    constructor(event) {
+        this.event = event;
+    }
+    process() {
+        let file = this.event.file;
+        this.event.program.logger.time(Logger_1.LogLevel.log, ['Processing completions'], () => {
+            // Find the scopes for this file - Only process the first few scopes
+            const scopesToProcess = this.getScopesForCompletion();
+            //get the completions from all scopes for this file
+            let completionResults = [];
+            let globalResults = [];
+            if ((0, reflection_1.isXmlFile)(file)) {
+                completionResults = this.getXmlFileCompletions(this.event.position, file);
+            }
+            else if ((0, reflection_1.isBrsFile)(file)) {
+                //handle script import completions
+                let scriptImport = util_1.util.getScriptImportAtPosition(file.ownScriptImports, this.event.position);
+                if (scriptImport) {
+                    this.event.completions.push(...this.getScriptImportCompletions(file.program, file.pkgPath, scriptImport));
+                    return;
+                }
+                const results = this.getBrsFileCompletions(this.event.position, file, scopesToProcess);
+                completionResults = results.scoped;
+                globalResults = results.global;
+            }
+            //push any global results to the completions array
+            this.event.completions.push(...globalResults);
+            //only keep completions common to every scope for this file (the global results are not considered in this filter and will always be included)
+            let allCompletions = completionResults.flat();
+            let keyCounts = new Map();
+            for (let completion of allCompletions) {
+                let key = `${completion.label}-${completion.kind}`;
+                keyCounts.set(key, keyCounts.has(key) ? keyCounts.get(key) + 1 : 1);
+                if (keyCounts.get(key) === scopesToProcess.length) {
+                    this.event.completions.push(completion);
+                }
+            }
+        });
+    }
+    getScopesForCompletion() {
+        var _a;
+        //the scopes for this file
+        let scopesForFile = (_a = this.event.scopes) !== null && _a !== void 0 ? _a : [];
+        // //if there are no scopes, include the global scope so we at least get the built-in functions
+        // if (this.event.program) {
+        //     scopesForFile = scopesForFile.length > 0 ? scopesForFile : [];
+        // }
+        // Only process the first few scopes. This might result in missing completions,
+        // but it's better than wasting TONS of cycles building essentially the same completions over and over
+        const scopesToProcess = scopesForFile.slice(0, SCOPES_FOR_COMPLETION);
+        // always include the source scope if applicable to this file
+        let sourceScope = scopesForFile.find(x => x.name === 'source');
+        if (sourceScope && !scopesToProcess.includes(sourceScope)) {
+            //replace the first scope with the source scope so we process a consistent number of scopes if possible
+            scopesToProcess[0] = sourceScope;
+        }
+        return scopesToProcess;
+    }
+    /**
+     * Get all available completions for the specified position
+     * @param position the position to get completions
+     */
+    getXmlFileCompletions(position, file) {
+        let scriptImport = util_1.util.getScriptImportAtPosition(file.scriptTagImports, position);
+        if (scriptImport) {
+            return this.getScriptImportCompletions(file.program, file.pkgPath, scriptImport);
+        }
+        else {
+            return [];
+        }
+    }
+    /**
+     * Get a list of all script imports, relative to the specified pkgPath
+     * @param program - reference to the program
+     * @param sourcePkgPath - the pkgPath of the source that wants to resolve script imports
+     * @param scriptImport - example script import
+     */
+    getScriptImportCompletions(program, sourcePkgPath, scriptImport) {
+        let lowerSourcePkgPath = sourcePkgPath.toLowerCase();
+        let result = [];
+        /**
+         * hashtable to prevent duplicate results
+         */
+        let resultPkgPaths = {};
+        //restrict to only .brs files
+        for (let key in program.files) {
+            let file = program.files[key];
+            const ext = util_1.util.getExtension(file.srcPath);
+            if (
+            //is a BrightScript or BrighterScript file
+            (ext === '.bs' || ext === '.brs') &&
+                //this file is not the current file
+                lowerSourcePkgPath !== file.pkgPath.toLowerCase()) {
+                //add the relative path
+                let relativePath = util_1.util.getRelativePath(sourcePkgPath, file.destPath).replace(/\\/g, '/');
+                let pkgPathStandardized = file.pkgPath.replace(/\\/g, '/');
+                let filePkgPath = `pkg:/${pkgPathStandardized}`;
+                let importPkgPath = util_1.util.getImportPackagePath(file.srcPath, filePkgPath);
+                let lowerFilePkgPath = filePkgPath.toLowerCase();
+                if (!resultPkgPaths[lowerFilePkgPath]) {
+                    resultPkgPaths[lowerFilePkgPath] = true;
+                    result.push({
+                        label: relativePath,
+                        detail: file.srcPath,
+                        kind: vscode_languageserver_1.CompletionItemKind.File,
+                        textEdit: {
+                            newText: relativePath,
+                            range: scriptImport.filePathRange
+                        }
+                    });
+                    //add the absolute path
+                    result.push({
+                        label: importPkgPath,
+                        detail: file.srcPath,
+                        kind: vscode_languageserver_1.CompletionItemKind.File,
+                        textEdit: {
+                            newText: importPkgPath,
+                            range: scriptImport.filePathRange
+                        }
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get completions available at the given cursor. This aggregates all values from this file and the current scope.
+     */
+    getBrsFileCompletions(position, file, scopesToProcess) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        let result = [];
+        const currentTokenByFilePosition = file.getTokenAt(position);
+        const currentToken = currentTokenByFilePosition !== null && currentTokenByFilePosition !== void 0 ? currentTokenByFilePosition : file.getTokenAt((_b = (_a = file.getClosestExpression(position)) === null || _a === void 0 ? void 0 : _a.location) === null || _b === void 0 ? void 0 : _b.range.start);
+        const emptyResult = { global: [], scoped: [] };
+        if (!currentToken) {
+            return emptyResult;
+        }
+        const tokenKind = currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind;
+        //if cursor is after a comment, disable completions
+        if (this.isPostionInComment(file, position)) {
+            return emptyResult;
+        }
+        let expression;
+        let shouldLookForMembers = false;
+        let shouldLookForCallFuncMembers = false;
+        let symbolTableLookupFlag = 1 /* SymbolTypeFlag.runtime */;
+        let beforeDotToken;
+        if (file.tokenFollows(currentToken, TokenKind_1.TokenKind.Goto)) {
+            let functionScope = file.getFunctionScopeAtPosition(position);
+            return { global: [], scoped: this.getLabelCompletion(functionScope) };
+        }
+        if (this.isTokenAdjacentTo(file, currentToken, TokenKind_1.TokenKind.Dot)) {
+            const dotToken = this.getAdjacentToken(file, currentToken, TokenKind_1.TokenKind.Dot);
+            beforeDotToken = file.getTokenBefore(dotToken);
+            expression = file.getClosestExpression((_c = beforeDotToken === null || beforeDotToken === void 0 ? void 0 : beforeDotToken.location) === null || _c === void 0 ? void 0 : _c.range.end);
+            shouldLookForMembers = true;
+        }
+        else if (this.isTokenAdjacentTo(file, currentToken, TokenKind_1.TokenKind.Callfunc)) {
+            const dotToken = this.getAdjacentToken(file, currentToken, TokenKind_1.TokenKind.Callfunc);
+            beforeDotToken = file.getTokenBefore(dotToken);
+            expression = file.getClosestExpression((_d = beforeDotToken === null || beforeDotToken === void 0 ? void 0 : beforeDotToken.location) === null || _d === void 0 ? void 0 : _d.range.end);
+            shouldLookForCallFuncMembers = true;
+        }
+        else if (this.isTokenAdjacentTo(file, currentToken, TokenKind_1.TokenKind.As)) {
+            if (file.parseMode === Parser_1.ParseMode.BrightScript) {
+                return { global: exports.NativeTypeCompletions, scoped: [] };
+            }
+            expression = file.getClosestExpression(this.event.position);
+            symbolTableLookupFlag = 2 /* SymbolTypeFlag.typetime */;
+        }
+        else if (this.isTokenAdjacentTo(file, currentToken, TokenKind_1.TokenKind.Equal)) {
+            expression = file.getClosestExpression(this.event.position);
+            if (expression === null || expression === void 0 ? void 0 : expression.findAncestor(reflection_1.isAliasStatement)) {
+                // allow runtime and typetime lookups in alias statements
+                // eslint-disable-next-line no-bitwise
+                symbolTableLookupFlag = 1 /* SymbolTypeFlag.runtime */ | 2 /* SymbolTypeFlag.typetime */;
+            }
+        }
+        else {
+            expression = file.getClosestExpression(this.event.position);
+        }
+        if ((0, reflection_1.isFunctionExpression)(expression)) {
+            // if completion is the last character of the function, use the completions of the body of the function
+            expression = expression.body;
+        }
+        if (!expression) {
+            return emptyResult;
+        }
+        const tokenBefore = file.getTokenBefore(file.getClosestToken((_f = (_e = expression.location) === null || _e === void 0 ? void 0 : _e.range) === null || _f === void 0 ? void 0 : _f.start));
+        // helper to check get correct symbol tables for look ups
+        function getSymbolTableForLookups() {
+            if (shouldLookForMembers) {
+                let type = expression.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+                if ((0, reflection_1.isEnumType)(type) && !(0, reflection_1.isEnumType)(expression.getType({ flags: 2 /* SymbolTypeFlag.typetime */ }))) {
+                    // enum members are registered in the symbol table as enum type
+                    // an enum type should ONLY use the enum type's members when called directly
+                    // since this is not a typetime enum, the actual type is actually an enum member!
+                    type = type.defaultMemberType;
+                }
+                // Make sure built in interfaces are added.
+                if (type.isResolvable()) {
+                    type.addBuiltInInterfaces();
+                }
+                return type === null || type === void 0 ? void 0 : type.getMemberTable();
+            }
+            else if (shouldLookForCallFuncMembers) {
+                let type = expression.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+                if ((0, reflection_1.isComponentType)(type)) {
+                    // it's a component and you're doing a callFunc - only let it do functions from that table
+                    return type.getCallFuncTable();
+                }
+                // this is not a component type - there should be no callfunc members
+                return undefined;
+            }
+            const symbolTableToUse = expression.getSymbolTable();
+            return symbolTableToUse;
+        }
+        const areMembers = (shouldLookForMembers || shouldLookForCallFuncMembers);
+        const notMembers = !areMembers;
+        const isAfterNew = (tokenBefore === null || tokenBefore === void 0 ? void 0 : tokenBefore.kind) === TokenKind_1.TokenKind.New;
+        const shouldLookInNamespace = notMembers && expression.findAncestor(reflection_1.isNamespaceStatement);
+        const containingClassStmt = expression.findAncestor(reflection_1.isClassStatement);
+        const containingNamespace = expression.findAncestor(reflection_1.isNamespaceStatement);
+        const containingNamespaceName = containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.getName(Parser_1.ParseMode.BrighterScript);
+        const containingFunctionExpression = expression.findAncestor(reflection_1.isFunctionExpression);
+        const tokenIsLiteralString = (tokenKind === TokenKind_1.TokenKind.StringLiteral || tokenKind === TokenKind_1.TokenKind.TemplateStringQuasi);
+        const globalCompletions = [];
+        if (!tokenIsLiteralString && notMembers && !isAfterNew && ((_g = this.event.program) === null || _g === void 0 ? void 0 : _g.globalScope)) {
+            let globalSymbols = (_h = this.event.program.globalScope.symbolTable.getAllSymbols(symbolTableLookupFlag)) !== null && _h !== void 0 ? _h : [];
+            if (symbolTableLookupFlag === 1 /* SymbolTypeFlag.runtime */) {
+                globalSymbols.push(...this.getGlobalValues());
+            }
+            globalCompletions.push(...this.getSymbolsCompletion(globalSymbols));
+        }
+        for (const scope of scopesToProcess) {
+            if (tokenKind === TokenKind_1.TokenKind.StringLiteral || tokenKind === TokenKind_1.TokenKind.TemplateStringQuasi) {
+                result.push(...this.getStringLiteralCompletions(scope, currentToken));
+                continue;
+            }
+            scope.linkSymbolTable();
+            const symbolTable = getSymbolTableForLookups();
+            let currentSymbols = [];
+            if (areMembers) {
+                currentSymbols = (_j = symbolTable === null || symbolTable === void 0 ? void 0 : symbolTable.getAllSymbols(symbolTableLookupFlag)) !== null && _j !== void 0 ? _j : [];
+                const tokenType = expression.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+                if ((0, reflection_1.isClassType)(tokenType)) {
+                    currentSymbols = currentSymbols.filter((symbol) => {
+                        if (symbol.name === 'new') {
+                            // don't return the constructor as a property
+                            return false;
+                        }
+                        return this.isMemberAccessible(scope, symbol, containingClassStmt, containingNamespaceName);
+                    });
+                }
+            }
+            else {
+                currentSymbols = (_k = symbolTable === null || symbolTable === void 0 ? void 0 : symbolTable.getOwnSymbols(symbolTableLookupFlag)) !== null && _k !== void 0 ? _k : [];
+                if (containingFunctionExpression) {
+                    if (symbolTable !== containingFunctionExpression.body.symbolTable) {
+                        // this is a pocket table - get all symbols defined in full function
+                        currentSymbols.push(...containingFunctionExpression.body.getSymbolTable().getOwnSymbols(symbolTableLookupFlag));
+                    }
+                    currentSymbols.push(...containingFunctionExpression.getSymbolTable().getOwnSymbols(symbolTableLookupFlag));
+                }
+                if (shouldLookInNamespace) {
+                    const nsNameParts = shouldLookInNamespace.getNameParts();
+                    let nameSpaceTypeSofar;
+                    let nsNameLookupTable = scope.symbolTable;
+                    for (const namePart of nsNameParts) {
+                        nameSpaceTypeSofar = nsNameLookupTable === null || nsNameLookupTable === void 0 ? void 0 : nsNameLookupTable.getSymbolType(namePart.text, { flags: symbolTableLookupFlag });
+                        if ((0, reflection_1.isNamespaceType)(nameSpaceTypeSofar)) {
+                            nsNameLookupTable = nameSpaceTypeSofar.getMemberTable();
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    if ((0, reflection_1.isNamespaceType)(nameSpaceTypeSofar)) {
+                        currentSymbols.push(...nameSpaceTypeSofar.getMemberTable().getAllSymbols(symbolTableLookupFlag));
+                    }
+                }
+                currentSymbols.push(...this.getScopeSymbolCompletions(file, scope, symbolTableLookupFlag));
+            }
+            let ignoreAllPropertyNames = false;
+            if (isAfterNew) {
+                //we are after a new keyword; so we can only be namespaces that have a class or classes at this point
+                currentSymbols = currentSymbols.filter(symbol => (0, reflection_1.isClassType)(symbol.type) || this.isNamespaceTypeWithMemberType(symbol.type, reflection_1.isClassType));
+                ignoreAllPropertyNames = true;
+            }
+            result.push(...this.getSymbolsCompletion(currentSymbols, areMembers));
+            if (shouldLookForMembers && currentSymbols.length === 0 && !ignoreAllPropertyNames) {
+                // could not find members of actual known types.. just try everything
+                result.push(...this.getPropertyNameCompletions(scope), ...this.getAllClassMemberCompletions(scope).values());
+            }
+            else if (shouldLookForCallFuncMembers && currentSymbols.length === 0) {
+                // could not find members of actual known types.. just try everything
+                result.push(...this.getCallFuncNameCompletions(scope));
+            }
+            scope.unlinkSymbolTable();
+        }
+        return { global: globalCompletions, scoped: result };
+    }
+    getScopeSymbolCompletions(file, scope, symbolTableLookupFlag) {
+        // get all scope available symbols
+        const scopeSymbols = file.parseMode === Parser_1.ParseMode.BrighterScript
+            ? [...scope.symbolTable.getOwnSymbols(symbolTableLookupFlag), ...scope.allNamespaceTypeTable.getOwnSymbols(symbolTableLookupFlag)]
+            : scope.symbolTable.getOwnSymbols(symbolTableLookupFlag);
+        const fileSymbols = file.ast.getSymbolTable().getOwnSymbols(symbolTableLookupFlag);
+        scopeSymbols.push(...fileSymbols);
+        const scopeAvailableSymbols = scopeSymbols.filter(sym => {
+            if (file.parseMode === Parser_1.ParseMode.BrighterScript) {
+                // eslint-disable-next-line no-bitwise
+                if (sym.flags & 32 /* SymbolTypeFlag.postTranspile */) {
+                    // underscored symbols should not be available in Brighterscript files
+                    return false;
+                }
+            }
+            else if (file.parseMode === Parser_1.ParseMode.BrightScript) {
+                if ((0, reflection_1.isNamespaceType)(sym.type)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        return scopeAvailableSymbols;
+    }
+    getSymbolsCompletion(symbols, areMembers = false) {
+        return symbols.map(symbol => {
+            var _a, _b, _c;
+            // if this is low priority, sort it at the end of the list
+            const sortText = ((_a = symbol.data) === null || _a === void 0 ? void 0 : _a.completionPriority) ? 'z'.repeat((_b = symbol.data) === null || _b === void 0 ? void 0 : _b.completionPriority) + symbol.name : undefined;
+            return {
+                label: symbol.name,
+                kind: this.getCompletionKindFromSymbol(symbol, areMembers),
+                detail: (_c = symbol === null || symbol === void 0 ? void 0 : symbol.type) === null || _c === void 0 ? void 0 : _c.toString(),
+                documentation: this.getDocumentation(symbol),
+                sortText: sortText
+            };
+        });
+    }
+    getDocumentation(symbol) {
+        var _a, _b, _c;
+        if ((_a = symbol.data) === null || _a === void 0 ? void 0 : _a.description) {
+            return (_b = symbol.data) === null || _b === void 0 ? void 0 : _b.description;
+        }
+        return util_1.util.getNodeDocumentation((_c = symbol.data) === null || _c === void 0 ? void 0 : _c.definingNode);
+    }
+    getCompletionKindFromSymbol(symbol, areMembers = false) {
+        var _a;
+        let type = symbol === null || symbol === void 0 ? void 0 : symbol.type;
+        if ((0, reflection_1.isTypeStatementType)(type)) {
+            type = type.wrappedType;
+        }
+        const extraData = symbol === null || symbol === void 0 ? void 0 : symbol.data;
+        let definingNode = extraData === null || extraData === void 0 ? void 0 : extraData.definingNode;
+        let isAlias = extraData === null || extraData === void 0 ? void 0 : extraData.isAlias;
+        let isInstance = extraData === null || extraData === void 0 ? void 0 : extraData.isInstance;
+        if ((0, reflection_1.isAliasStatement)(extraData === null || extraData === void 0 ? void 0 : extraData.definingNode)) {
+            isAlias = true;
+            const aliasExtraData = {};
+            type = extraData.definingNode.value.getType({ flags: symbol.flags, data: aliasExtraData });
+            definingNode = aliasExtraData === null || aliasExtraData === void 0 ? void 0 : aliasExtraData.definingNode;
+        }
+        if ((0, reflection_1.isConstStatement)(definingNode)) {
+            return vscode_languageserver_1.CompletionItemKind.Constant;
+        }
+        else if ((0, reflection_1.isClassType)(type) && !isInstance) {
+            return vscode_languageserver_1.CompletionItemKind.Class;
+        }
+        else if ((0, reflection_1.isCallableType)(type)) {
+            const finalTypeNameLower = type === null || type === void 0 ? void 0 : type.toString().split('.').pop().toLowerCase();
+            const symbolNameLower = symbol === null || symbol === void 0 ? void 0 : symbol.name.toLowerCase();
+            let nameMatchesType = symbolNameLower === finalTypeNameLower;
+            if ((0, reflection_1.isTypedFunctionType)(type) && !nameMatchesType) {
+                if (symbolNameLower === ((_a = type.name) === null || _a === void 0 ? void 0 : _a.replace(/\./gi, '_').toLowerCase())) {
+                    nameMatchesType = true;
+                }
+            }
+            if (nameMatchesType || isAlias) {
+                return areMembers ? vscode_languageserver_1.CompletionItemKind.Method : vscode_languageserver_1.CompletionItemKind.Function;
+            }
+        }
+        else if ((0, reflection_1.isInterfaceType)(type) && !isInstance) {
+            return vscode_languageserver_1.CompletionItemKind.Interface;
+        }
+        else if ((0, reflection_1.isEnumType)(type) && !isInstance) {
+            return vscode_languageserver_1.CompletionItemKind.Enum;
+        }
+        else if ((0, reflection_1.isEnumMemberType)(type)) {
+            return vscode_languageserver_1.CompletionItemKind.EnumMember;
+        }
+        else if ((0, reflection_1.isNamespaceType)(type)) {
+            return vscode_languageserver_1.CompletionItemKind.Module;
+        }
+        else if ((0, reflection_1.isComponentType)(type) && (!isInstance)) {
+            return vscode_languageserver_1.CompletionItemKind.Interface;
+        }
+        if (areMembers) {
+            return vscode_languageserver_1.CompletionItemKind.Field;
+        }
+        const lowerSymbolName = symbol.name.toLowerCase();
+        if (lowerSymbolName === 'true' ||
+            lowerSymbolName === 'false' ||
+            lowerSymbolName === 'invalid') {
+            return vscode_languageserver_1.CompletionItemKind.Value;
+        }
+        const tokenIdentifier = util_1.util.tokenToBscType((0, creators_1.createIdentifier)(symbol.name));
+        if ((0, reflection_1.isNativeType)(tokenIdentifier)) {
+            return vscode_languageserver_1.CompletionItemKind.Keyword;
+        }
+        return vscode_languageserver_1.CompletionItemKind.Variable;
+    }
+    isNamespaceTypeWithMemberType(nsType, predicate) {
+        if (!(0, reflection_1.isNamespaceType)(nsType)) {
+            return false;
+        }
+        const members = nsType.memberTable.getAllSymbols(1 /* SymbolTypeFlag.runtime */);
+        for (const member of members) {
+            if (predicate(member.type)) {
+                return true;
+            }
+            else if ((0, reflection_1.isNamespaceType)(member.type)) {
+                if (this.isNamespaceTypeWithMemberType(member.type, predicate)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    isMemberAccessible(scope, member, containingClassStmt, containingNamespaceName) {
+        var _a, _b;
+        // eslint-disable-next-line no-bitwise
+        const isPrivate = member.flags & 8 /* SymbolTypeFlag.private */;
+        // eslint-disable-next-line no-bitwise
+        const isProtected = member.flags & 16 /* SymbolTypeFlag.protected */;
+        if (!containingClassStmt || !(isPrivate || isProtected)) {
+            // not in a class - no private or protected members allowed
+            return !(isPrivate || isProtected);
+        }
+        const containingClassName = containingClassStmt.getName(Parser_1.ParseMode.BrighterScript);
+        const classStmtThatDefinedMember = (_b = (_a = member.data) === null || _a === void 0 ? void 0 : _a.definingNode) === null || _b === void 0 ? void 0 : _b.findAncestor(reflection_1.isClassStatement);
+        if (isPrivate) {
+            return containingClassStmt === classStmtThatDefinedMember;
+        }
+        else if (isProtected) {
+            const ancestorClasses = scope.getClassHierarchy(containingClassName, containingNamespaceName).map(link => link.item);
+            return ancestorClasses.includes(classStmtThatDefinedMember);
+        }
+        return true;
+    }
+    getLabelCompletion(functionScope) {
+        return functionScope.labelStatements.map(label => ({
+            label: label.name,
+            kind: vscode_languageserver_1.CompletionItemKind.Reference
+        }));
+    }
+    createCompletionFromFunctionStatement(statement, completionKind = vscode_languageserver_1.CompletionItemKind.Function) {
+        const funcType = statement.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+        return {
+            label: statement.getName(Parser_1.ParseMode.BrighterScript),
+            kind: completionKind,
+            detail: funcType.toString(),
+            documentation: util_1.util.getNodeDocumentation(statement)
+        };
+    }
+    getStringLiteralCompletions(scope, currentToken) {
+        var _a, _b, _c, _d;
+        const match = /^("?)(pkg|libpkg):/.exec(currentToken.text);
+        let result = [];
+        if (match) {
+            // Get file path locations
+            const [, openingQuote, fileProtocol] = match;
+            //include every absolute file path from this scope
+            for (const file of scope.getAllFiles()) {
+                const pkgPath = `${fileProtocol}:/${file.pkgPath.replace(/\\/g, '/')}`;
+                result.push({
+                    label: pkgPath,
+                    textEdit: vscode_languageserver_1.TextEdit.replace(util_1.util.createRange((_a = currentToken.location) === null || _a === void 0 ? void 0 : _a.range.start.line, 
+                    //+1 to step past the opening quote
+                    ((_b = currentToken.location) === null || _b === void 0 ? void 0 : _b.range.start.character) + (openingQuote ? 1 : 0), (_c = currentToken.location) === null || _c === void 0 ? void 0 : _c.range.end.line, 
+                    //-1 to exclude the closing quotemark (or the end character if there is no closing quotemark)
+                    ((_d = currentToken.location) === null || _d === void 0 ? void 0 : _d.range.end.character) + (currentToken.text.endsWith('"') ? -1 : 0)), pkgPath),
+                    kind: vscode_languageserver_1.CompletionItemKind.File
+                });
+            }
+            return result;
+        }
+        else {
+            //do nothing. we don't want to show completions inside of strings...
+            return [];
+        }
+    }
+    /**
+     * Scan all files for property names, and return them as completions
+     */
+    getPropertyNameCompletions(scope) {
+        let results = [];
+        scope.enumerateBrsFiles((file) => {
+            results.push(...file.propertyNameCompletions);
+        });
+        return results;
+    }
+    getAllClassMemberCompletions(scope) {
+        let results = new Map();
+        let filesSearched = new Set();
+        for (const file of scope.getAllFiles()) {
+            if ((0, reflection_1.isBrsFile)(file) && !filesSearched.has(file)) {
+                // eslint-disable-next-line @typescript-eslint/dot-notation
+                for (let cs of file['_cachedLookups'].classStatements) {
+                    for (let s of [...cs.methods, ...cs.fields]) {
+                        if (!results.has(s.tokens.name.text) && s.tokens.name.text.toLowerCase() !== 'new') {
+                            results.set(s.tokens.name.text, {
+                                label: s.tokens.name.text,
+                                kind: (0, reflection_1.isMethodStatement)(s) ? vscode_languageserver_1.CompletionItemKind.Method : vscode_languageserver_1.CompletionItemKind.Field
+                            });
+                        }
+                    }
+                }
+            }
+            filesSearched.add(file);
+        }
+        return results;
+    }
+    /**
+     * Scan all xmlScopes for call funcs
+     */
+    getCallFuncNameCompletions(scope) {
+        let completionsArray = [];
+        let completetionsLabels = [];
+        const xmlScopes = this.event.program.getScopes().filter((s) => (0, reflection_1.isXmlScope)(s));
+        // is next to a @. callfunc invocation - must be an component interface method.
+        for (const scope of xmlScopes) {
+            let fileLinks = this.event.program.getStatementsForXmlFile(scope);
+            for (let fileLink of fileLinks) {
+                let pushItem = this.createCompletionFromFunctionStatement(fileLink.item, vscode_languageserver_1.CompletionItemKind.Method);
+                if (!completetionsLabels.includes(pushItem.label)) {
+                    completetionsLabels.push(pushItem.label);
+                    completionsArray.push(pushItem);
+                }
+            }
+        }
+        //no other result is possible in this case
+        return completionsArray;
+    }
+    getGlobalValues() {
+        return [
+            {
+                name: 'true',
+                type: BooleanType_1.BooleanType.instance,
+                flags: 1 /* SymbolTypeFlag.runtime */,
+                data: {}
+            },
+            {
+                name: 'false',
+                type: BooleanType_1.BooleanType.instance,
+                flags: 1 /* SymbolTypeFlag.runtime */,
+                data: {}
+            },
+            {
+                name: 'invalid',
+                type: InvalidType_1.InvalidType.instance,
+                flags: 1 /* SymbolTypeFlag.runtime */,
+                data: {}
+            }
+        ];
+    }
+    isPostionInComment(file, position) {
+        var _a;
+        const currentToken = file.getCurrentOrNextTokenAt(position);
+        const tokenKind = currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind;
+        if (!currentToken) {
+            return true;
+        }
+        if (tokenKind === TokenKind_1.TokenKind.Comment) {
+            return true;
+        }
+        const nextNonComment = file.getNextTokenByPredicate(currentToken, (t) => !TokenKind_1.AllowedTriviaTokens.includes(t.kind), 1);
+        const firstComment = nextNonComment === null || nextNonComment === void 0 ? void 0 : nextNonComment.leadingTrivia.find(t => t.kind === TokenKind_1.TokenKind.Comment);
+        if (firstComment && util_1.util.comparePosition(position, (_a = firstComment === null || firstComment === void 0 ? void 0 : firstComment.location) === null || _a === void 0 ? void 0 : _a.range.start) >= 0) {
+            return true;
+        }
+        return false;
+    }
+    isTokenAdjacentTo(file, currentToken, targetKind) {
+        var _a;
+        return ((_a = file.getPreviousToken(currentToken)) === null || _a === void 0 ? void 0 : _a.kind) === targetKind || file.isTokenNextToTokenKind(currentToken, targetKind);
+    }
+    getAdjacentToken(file, currentToken, targetKind) {
+        return currentToken.kind === targetKind ? currentToken : file.getTokenBefore(currentToken, targetKind);
+    }
+}
+exports.CompletionsProcessor = CompletionsProcessor;
+/**
+ * List of completions for all valid keywords/reserved words.
+ * Build this list once because it won't change for the lifetime of this process
+ */
+exports.KeywordCompletions = Object.keys(TokenKind_1.Keywords)
+    //remove any keywords with whitespace
+    .filter(x => !x.includes(' '))
+    //create completions
+    .map(x => {
+    return {
+        label: x,
+        kind: vscode_languageserver_1.CompletionItemKind.Keyword
+    };
+});
+/**
+ * List of completions for all valid intrinsic types.
+ * Build this list once because it won't change for the lifetime of this process
+ */
+exports.NativeTypeCompletions = TokenKind_1.DeclarableTypes
+    //create completions
+    .map(x => {
+    return {
+        label: x.toLowerCase(),
+        kind: vscode_languageserver_1.CompletionItemKind.Keyword
+    };
+});
+//# sourceMappingURL=CompletionsProcessor.js.map