brighterscript 1.0.0-alpha.24 → 1.0.0-alpha.25

package/dist/bscPlugin/completions/CompletionsProcessor.d.ts

@@ -1,6 +1,57 @@
-import type { ProvideCompletionsEvent } from '../../interfaces';
+import type { FileReference, ProvideCompletionsEvent } from '../../interfaces';
+import type { Scope } from '../../Scope';
+import type { CompletionItem, Position } from 'vscode-languageserver';
+import type { XmlFile } from '../../files/XmlFile';
+import type { Program } from '../../Program';
+import type { BrsFile } from '../../files/BrsFile';
+import type { FunctionStatement } from '../../parser/Statement';
 export declare class CompletionsProcessor {
     private event;
     constructor(event: ProvideCompletionsEvent);
     process(): void;
+    /**
+     * Get all available completions for the specified position
+     * @param position the position to get completions
+     */
+    getXmlFileCompletions(position: Position, file: XmlFile): CompletionItem[];
+    /**
+     * 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: Program, sourcePkgPath: string, scriptImport: FileReference): CompletionItem[];
+    /**
+     * Get completions available at the given cursor. This aggregates all values from this file and the current scope.
+     */
+    getBrsFileCompletions(position: Position, file: BrsFile): CompletionItem[];
+    private getScopeSymbolCompletions;
+    private getSymbolsCompletion;
+    private getDocumentation;
+    private getCompletionKindFromSymbol;
+    private isNamespaceTypeWithMemberType;
+    private isMemberAccessible;
+    private getLabelCompletion;
+    createCompletionFromFunctionStatement(statement: FunctionStatement): CompletionItem;
+    private getStringLiteralCompletions;
+    /**
+     * Scan all files for property names, and return them as completions
+     */
+    getPropertyNameCompletions(scope: Scope): CompletionItem[];
+    getAllClassMemberCompletions(scope: Scope): Map<string, CompletionItem>;
+    /**
+     * Scan all xmlScopes for call funcs
+     */
+    getCallFuncNameCompletions(scope: Scope): CompletionItem[];
+    private getGlobalValues;
 }
+/**
+ * List of completions for all valid keywords/reserved words.
+ * Build this list once because it won't change for the lifetime of this process
+ */
+export declare const KeywordCompletions: CompletionItem[];
+/**
+ * List of completions for all valid intrinsic types.
+ * Build this list once because it won't change for the lifetime of this process
+ */
+export declare const NativeTypeCompletions: CompletionItem[];

package/dist/bscPlugin/completions/CompletionsProcessor.js

@@ -1,43 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompletionsProcessor = void 0;
+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 SymbolTable_1 = require("../../SymbolTable");
+const types_1 = require("../../types");
+const creators_1 = require("../../astUtils/creators");
 class CompletionsProcessor {
     constructor(event) {
         this.event = event;
     }
     process() {
-        let completionsArray = [];
-        if ((0, reflection_1.isBrsFile)(this.event.file) && this.event.file.parser.isPositionNextToTokenKind(this.event.position, TokenKind_1.TokenKind.Callfunc)) {
-            const xmlScopes = this.event.program.getScopes().filter((s) => (0, reflection_1.isXmlScope)(s));
-            // is next to a @. callfunc invocation - must be an interface method.
-            //TODO refactor this to utilize the actual variable's component type (when available)
-            for (const scope of xmlScopes) {
-                let fileLinks = this.event.program.getStatementsForXmlFile(scope);
-                for (let fileLink of fileLinks) {
-                    let pushItem = scope.createCompletionFromFunctionStatement(fileLink.item);
-                    if (!completionsArray.includes(pushItem.label)) {
-                        completionsArray.push(pushItem.label);
-                        this.event.completions.push(pushItem);
-                    }
-                }
-            }
-            //no other result is possible in this case
-            return;
-        }
+        let file = this.event.file;
         //find the scopes for this file
-        let scopesForFile = this.event.program.getScopesForFile(this.event.file);
+        let scopesForFile = this.event.program.getScopesForFile(file);
         //if there are no scopes, include the global scope so we at least get the built-in functions
         scopesForFile = scopesForFile.length > 0 ? scopesForFile : [this.event.program.globalScope];
         //get the completions from all scopes for this file
-        let allCompletions = util_1.util.flatMap(scopesForFile.map(scope => {
-            scope.linkSymbolTable();
-            const completions = this.event.file.getCompletions(this.event.position, scope);
-            scope.unlinkSymbolTable();
-            return completions;
-        }), c => c);
+        let completionResults = [];
+        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;
+            }
+            completionResults = this.getBrsFileCompletions(this.event.position, file);
+        }
+        let allCompletions = completionResults.flat();
         //only keep completions common to every scope for this file
         let keyCounts = new Map();
         for (let completion of allCompletions) {
@@ -48,6 +44,501 @@ class CompletionsProcessor {
             }
         }
     }
+    /**
+     * 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 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: filePkgPath,
+                        detail: file.srcPath,
+                        kind: vscode_languageserver_1.CompletionItemKind.File,
+                        textEdit: {
+                            newText: filePkgPath,
+                            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) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        let result = [];
+        const currentToken = (_a = file.getTokenAt(position)) !== null && _a !== void 0 ? _a : file.getTokenAt((_b = file.getClosestExpression(position)) === null || _b === void 0 ? void 0 : _b.range.start);
+        if (!currentToken) {
+            return [];
+        }
+        //if cursor is within a comment, disable completions
+        const tokenKind = currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind;
+        if (tokenKind === TokenKind_1.TokenKind.Comment) {
+            return [];
+        }
+        let expression;
+        let shouldLookForMembers = false;
+        let shouldLookForCallFuncMembers = false;
+        let symbolTableLookupFlag = SymbolTable_1.SymbolTypeFlag.runtime;
+        let beforeDotToken;
+        if (file.tokenFollows(currentToken, TokenKind_1.TokenKind.Goto)) {
+            let functionScope = file.getFunctionScopeAtPosition(position);
+            return this.getLabelCompletion(functionScope);
+        }
+        if (((_c = file.getPreviousToken(currentToken)) === null || _c === void 0 ? void 0 : _c.kind) === TokenKind_1.TokenKind.Dot || file.isTokenNextToTokenKind(currentToken, TokenKind_1.TokenKind.Dot)) {
+            const dotToken = currentToken.kind === TokenKind_1.TokenKind.Dot ? currentToken : file.getTokenBefore(currentToken, TokenKind_1.TokenKind.Dot);
+            beforeDotToken = file.getTokenBefore(dotToken);
+            expression = file.getClosestExpression(beforeDotToken === null || beforeDotToken === void 0 ? void 0 : beforeDotToken.range.end);
+            shouldLookForMembers = true;
+        }
+        else if (((_d = file.getPreviousToken(currentToken)) === null || _d === void 0 ? void 0 : _d.kind) === TokenKind_1.TokenKind.Callfunc || file.isTokenNextToTokenKind(currentToken, TokenKind_1.TokenKind.Callfunc)) {
+            const dotToken = currentToken.kind === TokenKind_1.TokenKind.Callfunc ? currentToken : file.getTokenBefore(currentToken, TokenKind_1.TokenKind.Callfunc);
+            beforeDotToken = file.getTokenBefore(dotToken);
+            expression = file.getClosestExpression(beforeDotToken === null || beforeDotToken === void 0 ? void 0 : beforeDotToken.range.end);
+            shouldLookForCallFuncMembers = true;
+        }
+        else if (((_e = file.getPreviousToken(currentToken)) === null || _e === void 0 ? void 0 : _e.kind) === TokenKind_1.TokenKind.As || file.isTokenNextToTokenKind(currentToken, TokenKind_1.TokenKind.As)) {
+            if (file.parseMode === Parser_1.ParseMode.BrightScript) {
+                return exports.NativeTypeCompletions;
+            }
+            expression = file.getClosestExpression(this.event.position);
+            symbolTableLookupFlag = SymbolTable_1.SymbolTypeFlag.typetime;
+        }
+        else {
+            expression = file.getClosestExpression(this.event.position);
+        }
+        if (!expression) {
+            return [];
+        }
+        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;
+        }
+        const tokenBefore = file.getTokenBefore(file.getClosestToken(expression.range.start));
+        // helper to check get correct symbol tables for look ups
+        function getSymbolTableForLookups() {
+            if (shouldLookForMembers) {
+                let type = expression.getType({ flags: SymbolTable_1.SymbolTypeFlag.runtime });
+                if ((0, reflection_1.isEnumType)(type) && !(0, reflection_1.isEnumType)(expression.getType({ flags: SymbolTable_1.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: SymbolTable_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;
+        }
+        let gotSymbolsFromThisFile = false;
+        let gotSymbolsFromGlobal = false;
+        const shouldLookInNamespace = !(shouldLookForMembers || shouldLookForCallFuncMembers) && 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);
+        for (const scope of this.event.scopes) {
+            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 (shouldLookForMembers || shouldLookForCallFuncMembers) {
+                currentSymbols = (_f = symbolTable === null || symbolTable === void 0 ? void 0 : symbolTable.getAllSymbols(symbolTableLookupFlag)) !== null && _f !== void 0 ? _f : [];
+                const tokenType = expression.getType({ flags: SymbolTable_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 {
+                // get symbols directly from current symbol table and scope
+                if (!gotSymbolsFromThisFile) {
+                    currentSymbols = (_g = symbolTable === null || symbolTable === void 0 ? void 0 : symbolTable.getOwnSymbols(symbolTableLookupFlag)) !== null && _g !== void 0 ? _g : [];
+                    if ((0, reflection_1.isBlock)(expression) && (0, reflection_1.isFunctionExpression)(expression.parent)) {
+                        currentSymbols.push(...expression.parent.getSymbolTable().getOwnSymbols(symbolTableLookupFlag));
+                    }
+                    gotSymbolsFromThisFile = true;
+                }
+                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));
+                // get global symbols
+                if (!gotSymbolsFromGlobal) {
+                    currentSymbols.push(...this.event.program.globalScope.symbolTable.getOwnSymbols(symbolTableLookupFlag));
+                    if (symbolTableLookupFlag === SymbolTable_1.SymbolTypeFlag.runtime) {
+                        currentSymbols.push(...this.getGlobalValues());
+                    }
+                    gotSymbolsFromGlobal = true;
+                }
+            }
+            let ignoreAllPropertyNames = false;
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+            switch (tokenBefore.kind) {
+                case TokenKind_1.TokenKind.New:
+                    //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;
+                    break;
+            }
+            result.push(...this.getSymbolsCompletion(currentSymbols, shouldLookForMembers || shouldLookForCallFuncMembers));
+            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 result;
+    }
+    getScopeSymbolCompletions(file, scope, symbolTableLookupFlag) {
+        // get all scope available symbols
+        const scopeAvailableSymbols = scope.symbolTable.getOwnSymbols(symbolTableLookupFlag).filter(sym => {
+            if (file.parseMode === Parser_1.ParseMode.BrighterScript) {
+                // eslint-disable-next-line no-bitwise
+                if (sym.flags & SymbolTable_1.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) {
+        const type = symbol === null || symbol === void 0 ? void 0 : symbol.type;
+        const extraData = symbol === null || symbol === void 0 ? void 0 : symbol.data;
+        if ((0, reflection_1.isConstStatement)(extraData === null || extraData === void 0 ? void 0 : extraData.definingNode)) {
+            return vscode_languageserver_1.CompletionItemKind.Constant;
+        }
+        else if ((0, reflection_1.isClassType)(type)) {
+            return vscode_languageserver_1.CompletionItemKind.Class;
+        }
+        else if ((0, reflection_1.isCallableType)(type)) {
+            return areMembers ? vscode_languageserver_1.CompletionItemKind.Method : vscode_languageserver_1.CompletionItemKind.Function;
+        }
+        else if ((0, reflection_1.isInterfaceType)(type)) {
+            return vscode_languageserver_1.CompletionItemKind.Interface;
+        }
+        else if ((0, reflection_1.isEnumType)(type)) {
+            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)) {
+            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(SymbolTable_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 & SymbolTable_1.SymbolTypeFlag.private;
+        // eslint-disable-next-line no-bitwise
+        const isProtected = member.flags & SymbolTable_1.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) {
+        const funcType = statement.getType({ flags: SymbolTable_1.SymbolTypeFlag.runtime });
+        return {
+            label: statement.getName(Parser_1.ParseMode.BrighterScript),
+            kind: vscode_languageserver_1.CompletionItemKind.Function,
+            detail: funcType.toString(),
+            documentation: util_1.util.getNodeDocumentation(statement)
+        };
+    }
+    getStringLiteralCompletions(scope, currentToken) {
+        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(currentToken.range.start.line, 
+                    //+1 to step past the opening quote
+                    currentToken.range.start.character + (openingQuote ? 1 : 0), currentToken.range.end.line, 
+                    //-1 to exclude the closing quotemark (or the end character if there is no closing quotemark)
+                    currentToken.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.name.text) && s.name.text.toLowerCase() !== 'new') {
+                            results.set(s.name.text, {
+                                label: s.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.
+        //TODO refactor this to utilize the actual variable's component type (when available)
+        for (const scope of xmlScopes) {
+            let fileLinks = this.event.program.getStatementsForXmlFile(scope);
+            for (let fileLink of fileLinks) {
+                let pushItem = this.createCompletionFromFunctionStatement(fileLink.item);
+                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: types_1.BooleanType.instance,
+                flags: SymbolTable_1.SymbolTypeFlag.runtime,
+                data: {}
+            },
+            {
+                name: 'false',
+                type: types_1.BooleanType.instance,
+                flags: SymbolTable_1.SymbolTypeFlag.runtime,
+                data: {}
+            },
+            {
+                name: 'invalid',
+                type: types_1.InvalidType.instance,
+                flags: SymbolTable_1.SymbolTypeFlag.runtime,
+                data: {}
+            }
+        ];
+    }
 }
 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