brighterscript 0.66.0-alpha.9 → 0.67.1

package/dist/files/BrsFile.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrsFile = void 0;
+exports.KeywordCompletions = exports.BrsFile = void 0;
 const source_map_1 = require("source-map");
 const vscode_languageserver_1 = require("vscode-languageserver");
 const vscode_languageserver_2 = require("vscode-languageserver");
@@ -12,25 +12,32 @@ const Lexer_1 = require("../lexer/Lexer");
 const TokenKind_1 = require("../lexer/TokenKind");
 const Parser_1 = require("../parser/Parser");
 const DynamicType_1 = require("../types/DynamicType");
+const FunctionType_1 = require("../types/FunctionType");
+const VoidType_1 = require("../types/VoidType");
 const util_1 = require("../util");
 const BrsTranspileState_1 = require("../parser/BrsTranspileState");
 const Preprocessor_1 = require("../preprocessor/Preprocessor");
-const Logger_1 = require("../Logger");
 const serialize_error_1 = require("serialize-error");
 const reflection_1 = require("../astUtils/reflection");
 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");
+const DefinitionProvider_1 = require("../bscPlugin/definition/DefinitionProvider");
+const ReferencesProvider_1 = require("../bscPlugin/references/ReferencesProvider");
+const DocumentSymbolProcessor_1 = require("../bscPlugin/symbols/DocumentSymbolProcessor");
+const WorkspaceSymbolProcessor_1 = require("../bscPlugin/symbols/WorkspaceSymbolProcessor");
 /**
  * Holds all details about this file within the scope of the whole program
  */
 class BrsFile {
-    constructor(options) {
-        var _a, _b, _c;
-        this.type = 'BrsFile';
+    constructor(srcPath, 
+    /**
+     * The full pkg path to this file
+     */
+    pkgPath, program) {
+        var _a, _b;
+        this.srcPath = srcPath;
+        this.pkgPath = pkgPath;
+        this.program = program;
         /**
          * The parseMode used for the parser for this file
          */
@@ -47,53 +54,69 @@ class BrsFile {
         this.commentFlags = [];
         this.callables = [];
         this.functionCalls = [];
+        /**
+         * Does this file need to be transpiled?
+         */
+        this.needsTranspiled = false;
         this.scopesByFunc = new Map();
-        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();
-            }
+        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();
         }
     }
     /**
-     * @deprecated use `.diagnostics` instead
+     * The absolute path to the source location for this file
+     * @deprecated use `srcPath` instead
+     */
+    get pathAbsolute() {
+        return this.srcPath;
+    }
+    set pathAbsolute(value) {
+        this.srcPath = value;
+    }
+    /**
+     * Will this file result in only comment or whitespace output? If so, it can be excluded from the output if that bsconfig setting is enabled.
      */
+    get canBePruned() {
+        let canPrune = true;
+        this.ast.walk((0, visitors_1.createVisitor)({
+            FunctionStatement: () => {
+                canPrune = false;
+            },
+            ClassStatement: () => {
+                canPrune = false;
+            }
+        }), {
+            walkMode: visitors_1.WalkMode.visitStatements
+        });
+        return canPrune;
+    }
     getDiagnostics() {
-        return this.diagnostics;
+        return [...this.diagnostics];
     }
     addDiagnostic(diagnostic) {
-        if (!diagnostic.file) {
-            diagnostic.file = this;
-        }
-        this.diagnostics.push(diagnostic);
+        this.addDiagnostics([diagnostic]);
     }
     addDiagnostics(diagnostics) {
-        this.diagnostics.push(...diagnostics);
+        for (const diagnostic of diagnostics) {
+            if (!diagnostic.file) {
+                diagnostic.file = this;
+            }
+            this.diagnostics.push(diagnostic);
+        }
     }
     get functionScopes() {
         if (!this._functionScopes) {
@@ -119,7 +142,7 @@ class BrsFile {
                 if ((0, reflection_1.isImportStatement)(statement) && statement.filePathToken) {
                     result.push({
                         filePathRange: statement.filePathToken.range,
-                        destPath: util_1.util.getPkgPathFromTarget(this.destPath, statement.filePath),
+                        pkgPath: util_1.util.getPkgPathFromTarget(this.pkgPath, statement.filePath),
                         sourceFile: this,
                         text: (_d = statement.filePathToken) === null || _d === void 0 ? void 0 : _d.text
                     });
@@ -129,26 +152,11 @@ 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() {
-        var _a;
-        return (_a = this.parser) === null || _a === void 0 ? void 0 : _a.ast;
+        return this.parser.ast;
     }
     /**
      * Get the token at the specified position
@@ -202,25 +210,23 @@ 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) { }
-    /**
-     * The list of files that this file depends on
      */
-    get dependencies() {
-        const result = this.ownScriptImports.filter(x => !!x.destPath).map(x => x.destPath.toLowerCase());
+    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());
         //if this is a .brs file, watch for typedef changes
         if (this.extension === '.brs') {
-            result.push(util_1.util.getTypedefPath(this.destPath));
+            dependencies.push(util_1.util.getTypedefPath(this.pkgPath));
         }
-        return result;
+        dependencyGraph.addOrReplace(this.dependencyGraphKey, dependencies);
     }
     /**
      * Calculate the AST for this file
@@ -237,7 +243,7 @@ class BrsFile {
                 return;
             }
             //tokenize the input file
-            let lexer = this.program.logger.time(Logger_1.LogLevel.debug, ['lexer.lex', chalk_1.default.green(this.srcPath)], () => {
+            let lexer = this.program.logger.time('debug', ['lexer.lex', chalk_1.default.green(this.srcPath)], () => {
                 return Lexer_1.Lexer.scan(fileContents, {
                     includeWhitespace: false
                 });
@@ -248,7 +254,7 @@ class BrsFile {
             //TODO preprocessor should go away in favor of the AST handling this internally (because it affects transpile)
             //currently the preprocessor throws exceptions on syntax errors...so we need to catch it
             try {
-                this.program.logger.time(Logger_1.LogLevel.debug, ['preprocessor.process', chalk_1.default.green(this.srcPath)], () => {
+                this.program.logger.time('debug', ['preprocessor.process', chalk_1.default.green(this.srcPath)], () => {
                     preprocessor.process(lexer.tokens, this.program.getManifest());
                 });
             }
@@ -260,7 +266,7 @@ class BrsFile {
             }
             //if the preprocessor generated tokens, use them.
             let tokens = preprocessor.processedTokens.length > 0 ? preprocessor.processedTokens : lexer.tokens;
-            this.program.logger.time(Logger_1.LogLevel.debug, ['parser.parse', chalk_1.default.green(this.srcPath)], () => {
+            this.program.logger.time('debug', ['parser.parse', chalk_1.default.green(this.srcPath)], () => {
                 this._parser = Parser_1.Parser.parse(tokens, {
                     mode: this.parseMode,
                     logger: this.program.logger
@@ -282,6 +288,11 @@ class BrsFile {
             this.diagnostics.push(Object.assign({ file: this, range: util_1.util.createRange(0, 0, 0, Number.MAX_VALUE) }, DiagnosticMessages_1.DiagnosticMessages.genericParserMessage('Critical error parsing file: ' + JSON.stringify((0, serialize_error_1.serializeError)(e)))));
         }
     }
+    /**
+     * @deprecated logic has moved into BrsFileValidator, this is now an empty function
+     */
+    validate() {
+    }
     /**
      * Find a class. This scans all scopes for this file, and returns the first matching class that is found.
      * Returns undefined if not found.
@@ -338,7 +349,7 @@ class BrsFile {
      * Create a scope for every function in this file
      */
     createFunctionScopes() {
-        var _a;
+        var _a, _b, _c;
         //find every function
         let functions = this.parser.references.functionExpressions;
         //create a functionScope for every function
@@ -347,7 +358,7 @@ class BrsFile {
             let scope = new FunctionScope_1.FunctionScope(func);
             //find parent function, and add this scope to it if found
             {
-                let parentScope = this.scopesByFunc.get(func.findAncestor(reflection_1.isFunctionExpression));
+                let parentScope = this.scopesByFunc.get(func.parentFunction);
                 //add this child scope to its parent
                 if (parentScope) {
                     parentScope.childrenScopes.push(scope);
@@ -359,28 +370,28 @@ class BrsFile {
             for (let param of func.parameters) {
                 scope.variableDeclarations.push({
                     nameRange: param.name.range,
-                    lineIndex: param.name.range.start.line,
+                    lineIndex: (_a = param.name.range) === null || _a === void 0 ? void 0 : _a.start.line,
                     name: param.name.text,
-                    getType: () => {
-                        return param.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
-                    }
+                    type: param.type
                 });
             }
             //add all of ForEachStatement loop varibales
-            (_a = func.body) === null || _a === void 0 ? void 0 : _a.walk((0, visitors_1.createVisitor)({
+            (_b = func.body) === null || _b === void 0 ? void 0 : _b.walk((0, visitors_1.createVisitor)({
                 ForEachStatement: (stmt) => {
+                    var _a;
                     scope.variableDeclarations.push({
                         nameRange: stmt.item.range,
-                        lineIndex: stmt.item.range.start.line,
+                        lineIndex: (_a = stmt.item.range) === null || _a === void 0 ? void 0 : _a.start.line,
                         name: stmt.item.text,
-                        getType: () => DynamicType_1.DynamicType.instance //TODO: Infer types from array
+                        type: new DynamicType_1.DynamicType()
                     });
                 },
                 LabelStatement: (stmt) => {
+                    var _a;
                     const { identifier } = stmt.tokens;
                     scope.labelStatements.push({
                         nameRange: identifier.range,
-                        lineIndex: identifier.range.start.line,
+                        lineIndex: (_a = identifier.range) === null || _a === void 0 ? void 0 : _a.start.line,
                         name: identifier.text
                     });
                 }
@@ -395,36 +406,95 @@ class BrsFile {
         let assignmentStatements = this.parser.references.assignmentStatements;
         for (let statement of assignmentStatements) {
             //find this statement's function scope
-            let scope = this.scopesByFunc.get(statement.findAncestor(reflection_1.isFunctionExpression));
+            let scope = this.scopesByFunc.get(statement.containingFunction);
             //skip variable declarations that are outside of any scope
             if (scope) {
                 scope.variableDeclarations.push({
                     nameRange: statement.name.range,
-                    lineIndex: statement.name.range.start.line,
+                    lineIndex: (_c = statement.name.range) === null || _c === void 0 ? void 0 : _c.start.line,
                     name: statement.name.text,
-                    getType: () => {
-                        return statement.getType({ flags: SymbolTable_1.SymbolTypeFlag.runtime });
-                    }
+                    type: this.getBscTypeFromAssignment(statement, scope)
                 });
             }
         }
     }
+    getBscTypeFromAssignment(assignment, scope) {
+        var _a, _b, _c, _d;
+        try {
+            //function
+            if ((0, reflection_1.isFunctionExpression)(assignment.value)) {
+                let functionType = new FunctionType_1.FunctionType(assignment.value.returnType);
+                functionType.isSub = assignment.value.functionType.text === 'sub';
+                if (functionType.isSub) {
+                    functionType.returnType = new VoidType_1.VoidType();
+                }
+                functionType.setName(assignment.name.text);
+                for (let param of assignment.value.parameters) {
+                    let isOptional = !!param.defaultValue;
+                    //TODO compute optional parameters
+                    functionType.addParameter(param.name.text, param.type, isOptional);
+                }
+                return functionType;
+                //literal
+            }
+            else if ((0, reflection_1.isLiteralExpression)(assignment.value)) {
+                return assignment.value.type;
+                //function call
+            }
+            else if ((0, reflection_1.isCallExpression)(assignment.value)) {
+                let calleeName = (_b = (_a = assignment.value.callee) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.text;
+                if (calleeName) {
+                    let func = this.getCallableByName(calleeName);
+                    if (func) {
+                        return func.type.returnType;
+                    }
+                }
+            }
+            else if ((0, reflection_1.isVariableExpression)(assignment.value)) {
+                let variableName = (_d = (_c = assignment.value) === null || _c === void 0 ? void 0 : _c.name) === null || _d === void 0 ? void 0 : _d.text;
+                let variable = scope.getVariableByName(variableName);
+                return variable.type;
+            }
+        }
+        catch (e) {
+            //do nothing. Just return dynamic
+        }
+        //fallback to dynamic
+        return new DynamicType_1.DynamicType();
+    }
+    getCallableByName(name) {
+        name = name ? name.toLowerCase() : undefined;
+        if (!name) {
+            return;
+        }
+        for (let func of this.callables) {
+            if (func.name.toLowerCase() === name) {
+                return func;
+            }
+        }
+    }
     findCallables() {
         var _a;
         for (let statement of (_a = this.parser.references.functionStatements) !== null && _a !== void 0 ? _a : []) {
+            let functionType = new FunctionType_1.FunctionType(statement.func.returnType);
+            functionType.setName(statement.name.text);
+            functionType.isSub = statement.func.functionType.text.toLowerCase() === 'sub';
+            if (functionType.isSub) {
+                functionType.returnType = new VoidType_1.VoidType();
+            }
             //extract the parameters
             let params = [];
             for (let param of statement.func.parameters) {
-                const paramType = param.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
                 let callableParam = {
                     name: param.name.text,
-                    type: paramType,
+                    type: param.type,
                     isOptional: !!param.defaultValue,
                     isRestArgument: false
                 };
                 params.push(callableParam);
+                let isOptional = !!param.defaultValue;
+                functionType.addParameter(callableParam.name, callableParam.type, isOptional);
             }
-            const funcType = statement.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
             this.callables.push({
                 isSub: statement.func.functionType.text.toLowerCase() === 'sub',
                 name: statement.name.text,
@@ -432,7 +502,7 @@ class BrsFile {
                 file: this,
                 params: params,
                 range: statement.func.range,
-                type: funcType,
+                type: functionType,
                 getName: statement.getName.bind(statement),
                 hasNamespace: !!statement.findAncestor(reflection_1.isNamespaceStatement),
                 functionStatement: statement
@@ -466,7 +536,7 @@ class BrsFile {
                     if ((0, reflection_1.isLiteralExpression)(arg)) {
                         args.push({
                             range: arg.range,
-                            type: arg.getType(),
+                            type: arg.type,
                             text: arg.token.text,
                             expression: arg,
                             typeToken: undefined
@@ -521,8 +591,7 @@ class BrsFile {
                     name: functionName,
                     nameRange: util_1.util.createRange(callee.range.start.line, columnIndexBegin, callee.range.start.line, columnIndexEnd),
                     //TODO keep track of parameters
-                    args: args,
-                    expression: expression
+                    args: args
                 };
                 this.functionCalls.push(functionCall);
             }
@@ -568,37 +637,345 @@ class BrsFile {
             });
         }
     }
-    getNamespaceDefinitions(token, file) {
-        //BrightScript does not support namespaces, so return an empty list in that case
-        if (!token) {
-            return undefined;
+    /**
+     * Get completions available at the given cursor. This aggregates all values from this file and the current scope.
+     */
+    getCompletions(position, scope) {
+        let result = [];
+        //a map of lower-case names of all added options
+        let names = {};
+        //handle script import completions
+        let scriptImport = util_1.util.getScriptImportAtPosition(this.ownScriptImports, position);
+        if (scriptImport) {
+            return this.program.getScriptImportCompletions(this.pkgPath, scriptImport);
+        }
+        //if cursor is within a comment, disable completions
+        let currentToken = this.getTokenAt(position);
+        const tokenKind = currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind;
+        if (tokenKind === TokenKind_1.TokenKind.Comment) {
+            return [];
+        }
+        else if (tokenKind === TokenKind_1.TokenKind.StringLiteral || tokenKind === TokenKind_1.TokenKind.TemplateStringQuasi) {
+            const match = /^("?)(pkg|libpkg):/.exec(currentToken.text);
+            if (match) {
+                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_2.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_2.CompletionItemKind.File
+                    });
+                }
+                return result;
+            }
+            else {
+                //do nothing. we don't want to show completions inside of strings...
+                return [];
+            }
         }
-        let location;
-        const nameParts = this.getPartialVariableName(token, [TokenKind_1.TokenKind.New]).split('.');
-        const endName = nameParts[nameParts.length - 1].toLowerCase();
-        const namespaceName = nameParts.slice(0, -1).join('.').toLowerCase();
-        const statementHandler = (statement) => {
-            if (!location && statement.getName(Parser_1.ParseMode.BrighterScript).toLowerCase() === namespaceName) {
-                const namespaceItemStatementHandler = (statement) => {
-                    if (!location && statement.name.text.toLowerCase() === endName) {
-                        const uri = util_1.util.pathToUri(file.srcPath);
-                        location = util_1.util.createLocation(uri, statement.range);
+        const namespaceCompletions = this.getNamespaceCompletions(currentToken, this.parseMode, scope);
+        if (namespaceCompletions.length > 0) {
+            return [...namespaceCompletions];
+        }
+        const enumMemberCompletions = this.getEnumMemberStatementCompletions(currentToken, this.parseMode, scope);
+        if (enumMemberCompletions.length > 0) {
+            // no other completion is valid in this case
+            return enumMemberCompletions;
+        }
+        //determine if cursor is inside a function
+        let functionScope = this.getFunctionScopeAtPosition(position);
+        if (!functionScope) {
+            //we aren't in any function scope, so return the keyword completions and namespaces
+            if (this.getTokenBefore(currentToken, TokenKind_1.TokenKind.New)) {
+                // there's a new keyword, so only class types are viable here
+                return [...this.getGlobalClassStatementCompletions(currentToken, this.parseMode)];
+            }
+            else {
+                return [
+                    ...exports.KeywordCompletions,
+                    ...this.getGlobalClassStatementCompletions(currentToken, this.parseMode),
+                    ...namespaceCompletions,
+                    ...this.getNonNamespacedEnumStatementCompletions(currentToken, this.parseMode, scope)
+                ];
+            }
+        }
+        const classNameCompletions = this.getGlobalClassStatementCompletions(currentToken, this.parseMode);
+        const newToken = this.getTokenBefore(currentToken, TokenKind_1.TokenKind.New);
+        if (newToken) {
+            //we are after a new keyword; so we can only be top-level namespaces or classes at this point
+            result.push(...classNameCompletions);
+            result.push(...namespaceCompletions);
+            return result;
+        }
+        if (this.tokenFollows(currentToken, TokenKind_1.TokenKind.Goto)) {
+            return this.getLabelCompletion(functionScope);
+        }
+        if (this.isPositionNextToTokenKind(position, TokenKind_1.TokenKind.Dot)) {
+            const selfClassMemberCompletions = this.getClassMemberCompletions(position, currentToken, functionScope, scope);
+            if (selfClassMemberCompletions.size > 0) {
+                return [...selfClassMemberCompletions.values()].filter((i) => i.label !== 'new');
+            }
+            if (!this.getClassFromMReference(position, currentToken, functionScope)) {
+                //and anything from any class in scope to a non m class
+                let classMemberCompletions = scope.getAllClassMemberCompletions();
+                result.push(...classMemberCompletions.values());
+                result.push(...scope.getPropertyNameCompletions().filter((i) => !classMemberCompletions.has(i.label)));
+            }
+            else {
+                result.push(...scope.getPropertyNameCompletions());
+            }
+        }
+        else {
+            result.push(
+            //include namespaces
+            ...namespaceCompletions, 
+            //include class names
+            ...classNameCompletions, 
+            //include enums
+            ...this.getNonNamespacedEnumStatementCompletions(currentToken, this.parseMode, scope), 
+            //include constants
+            ...this.getNonNamespacedConstStatementCompletions(currentToken, this.parseMode, scope), 
+            //include the global callables
+            ...scope.getCallablesAsCompletions(this.parseMode));
+            //add `m` because that's always valid within a function
+            result.push({
+                label: 'm',
+                kind: vscode_languageserver_2.CompletionItemKind.Variable
+            });
+            names.m = true;
+            result.push(...exports.KeywordCompletions);
+            //include local variables
+            let variables = functionScope.variableDeclarations;
+            for (let variable of variables) {
+                //skip duplicate variable names
+                if (names[variable.name.toLowerCase()]) {
+                    continue;
+                }
+                names[variable.name.toLowerCase()] = true;
+                result.push({
+                    label: variable.name,
+                    kind: (0, reflection_1.isFunctionType)(variable.type) ? vscode_languageserver_2.CompletionItemKind.Function : vscode_languageserver_2.CompletionItemKind.Variable
+                });
+            }
+            if (this.parseMode === Parser_1.ParseMode.BrighterScript) {
+                //include the first part of namespaces
+                let namespaces = scope.getAllNamespaceStatements();
+                for (let stmt of namespaces) {
+                    let firstPart = stmt.nameExpression.getNameParts().shift();
+                    //skip duplicate namespace names
+                    if (names[firstPart.toLowerCase()]) {
+                        continue;
                     }
-                };
-                file.parser.ast.walk((0, visitors_1.createVisitor)({
-                    ClassStatement: namespaceItemStatementHandler,
-                    FunctionStatement: namespaceItemStatementHandler
-                }), {
-                    walkMode: visitors_1.WalkMode.visitStatements
+                    names[firstPart.toLowerCase()] = true;
+                    result.push({
+                        label: firstPart,
+                        kind: vscode_languageserver_2.CompletionItemKind.Module
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    getLabelCompletion(functionScope) {
+        return functionScope.labelStatements.map(label => ({
+            label: label.name,
+            kind: vscode_languageserver_2.CompletionItemKind.Reference
+        }));
+    }
+    getClassMemberCompletions(position, currentToken, functionScope, scope) {
+        var _a, _b, _c, _d;
+        let classStatement = this.getClassFromMReference(position, currentToken, functionScope);
+        let results = new Map();
+        if (classStatement) {
+            let classes = scope.getClassHierarchy(classStatement.item.getName(Parser_1.ParseMode.BrighterScript).toLowerCase());
+            for (let cs of classes) {
+                for (let member of [...(_b = (_a = cs === null || cs === void 0 ? void 0 : cs.item) === null || _a === void 0 ? void 0 : _a.fields) !== null && _b !== void 0 ? _b : [], ...(_d = (_c = cs === null || cs === void 0 ? void 0 : cs.item) === null || _c === void 0 ? void 0 : _c.methods) !== null && _d !== void 0 ? _d : []]) {
+                    if (!results.has(member.name.text.toLowerCase())) {
+                        results.set(member.name.text.toLowerCase(), {
+                            label: member.name.text,
+                            kind: (0, reflection_1.isFieldStatement)(member) ? vscode_languageserver_2.CompletionItemKind.Field : vscode_languageserver_2.CompletionItemKind.Function
+                        });
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    getClassFromMReference(position, currentToken, functionScope) {
+        let previousToken = this.getPreviousToken(currentToken);
+        if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind) === TokenKind_1.TokenKind.Dot) {
+            previousToken = this.getPreviousToken(previousToken);
+        }
+        if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind) === TokenKind_1.TokenKind.Identifier && (previousToken === null || previousToken === void 0 ? void 0 : previousToken.text.toLowerCase()) === 'm' && (0, reflection_1.isMethodStatement)(functionScope.func.functionStatement)) {
+            return { item: this.parser.references.classStatements.find((cs) => util_1.util.rangeContains(cs.range, position)), file: this };
+        }
+        return undefined;
+    }
+    getGlobalClassStatementCompletions(currentToken, parseMode) {
+        var _a;
+        if (parseMode === Parser_1.ParseMode.BrightScript) {
+            return [];
+        }
+        let results = new Map();
+        let completionName = (_a = this.getPartialVariableName(currentToken, [TokenKind_1.TokenKind.New])) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (completionName === null || completionName === void 0 ? void 0 : completionName.includes('.')) {
+            return [];
+        }
+        let scopes = this.program.getScopesForFile(this);
+        for (let scope of scopes) {
+            let classMap = scope.getClassMap();
+            for (const key of [...classMap.keys()]) {
+                let cs = classMap.get(key).item;
+                if (!results.has(cs.name.text)) {
+                    results.set(cs.name.text, {
+                        label: cs.name.text,
+                        kind: vscode_languageserver_2.CompletionItemKind.Class
+                    });
+                }
+            }
+        }
+        return [...results.values()];
+    }
+    getNonNamespacedEnumStatementCompletions(currentToken, parseMode, scope) {
+        var _a, _b;
+        if (parseMode !== Parser_1.ParseMode.BrighterScript) {
+            return [];
+        }
+        const containingNamespaceName = ((_b = this.getNamespaceStatementForPosition((_a = currentToken === null || currentToken === void 0 ? void 0 : currentToken.range) === null || _a === void 0 ? void 0 : _a.start)) === null || _b === void 0 ? void 0 : _b.name) + '.';
+        const results = new Map();
+        const enumMap = scope.getEnumMap();
+        for (const key of [...enumMap.keys()]) {
+            const enumStatement = enumMap.get(key).item;
+            const fullName = enumStatement.fullName;
+            //if the enum is contained within our own namespace, or if it's a non-namespaced enum
+            if (fullName.startsWith(containingNamespaceName) || !fullName.includes('.')) {
+                results.set(fullName, {
+                    label: enumStatement.name,
+                    kind: vscode_languageserver_2.CompletionItemKind.Enum
                 });
             }
-        };
-        file.parser.ast.walk((0, visitors_1.createVisitor)({
-            NamespaceStatement: statementHandler
-        }), {
-            walkMode: visitors_1.WalkMode.visitStatements
-        });
-        return location;
+        }
+        return [...results.values()];
+    }
+    getNonNamespacedConstStatementCompletions(currentToken, parseMode, scope) {
+        var _a, _b;
+        if (parseMode !== Parser_1.ParseMode.BrighterScript) {
+            return [];
+        }
+        const containingNamespaceName = ((_b = this.getNamespaceStatementForPosition((_a = currentToken === null || currentToken === void 0 ? void 0 : currentToken.range) === null || _a === void 0 ? void 0 : _a.start)) === null || _b === void 0 ? void 0 : _b.name) + '.';
+        const results = new Map();
+        const map = scope.getConstMap();
+        for (const key of [...map.keys()]) {
+            const statement = map.get(key).item;
+            const fullName = statement.fullName;
+            //if the item is contained within our own namespace, or if it's non-namespaced
+            if (fullName.startsWith(containingNamespaceName) || !fullName.includes('.')) {
+                results.set(fullName, {
+                    label: statement.name,
+                    kind: vscode_languageserver_2.CompletionItemKind.Constant
+                });
+            }
+        }
+        return [...results.values()];
+    }
+    getEnumMemberStatementCompletions(currentToken, parseMode, scope) {
+        var _a, _b, _c, _d, _e;
+        if (parseMode === Parser_1.ParseMode.BrightScript || !currentToken) {
+            return [];
+        }
+        const results = new Map();
+        const completionName = (_a = this.getPartialVariableName(currentToken)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        //if we don't have a completion name, or if there's no period in the name, then this is not to the right of an enum name
+        if (!completionName || !completionName.includes('.')) {
+            return [];
+        }
+        const enumNameLower = (_b = completionName === null || completionName === void 0 ? void 0 : completionName.split(/\.(\w+)?$/)[0]) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+        const namespaceNameLower = (_c = this.getNamespaceStatementForPosition(currentToken.range.end)) === null || _c === void 0 ? void 0 : _c.name.toLowerCase();
+        const enumMap = scope.getEnumMap();
+        //get the enum statement with this name (check without namespace prefix first, then with inferred namespace prefix next)
+        const enumStatement = (_e = ((_d = enumMap.get(enumNameLower)) !== null && _d !== void 0 ? _d : enumMap.get(namespaceNameLower + '.' + enumNameLower))) === null || _e === void 0 ? void 0 : _e.item;
+        //if we found an enum with this name
+        if (enumStatement) {
+            for (const member of enumStatement.getMembers()) {
+                const name = enumStatement.fullName + '.' + member.name;
+                const nameLower = name.toLowerCase();
+                results.set(nameLower, {
+                    label: member.name,
+                    kind: vscode_languageserver_2.CompletionItemKind.EnumMember
+                });
+            }
+        }
+        return [...results.values()];
+    }
+    getNamespaceCompletions(currentToken, parseMode, scope) {
+        //BrightScript does not support namespaces, so return an empty list in that case
+        if (parseMode === Parser_1.ParseMode.BrightScript) {
+            return [];
+        }
+        const completionName = this.getPartialVariableName(currentToken, [TokenKind_1.TokenKind.New]);
+        //if we don't have a completion name, or if there's no period in the name, then this is not a namespaced variable
+        if (!completionName || !completionName.includes('.')) {
+            return [];
+        }
+        //remove any trailing identifer and then any trailing dot, to give us the
+        //name of its immediate parent namespace
+        let closestParentNamespaceName = completionName.replace(/\.([a-z0-9_]*)?$/gi, '').toLowerCase();
+        let newToken = this.getTokenBefore(currentToken, TokenKind_1.TokenKind.New);
+        let result = new Map();
+        for (let [, namespace] of scope.namespaceLookup) {
+            //completionName = "NameA."
+            //completionName = "NameA.Na
+            //NameA
+            //NameA.NameB
+            //NameA.NameB.NameC
+            if (namespace.fullName.toLowerCase() === closestParentNamespaceName) {
+                //add all of this namespace's immediate child namespaces, bearing in mind if we are after a new keyword
+                for (let [, ns] of namespace.namespaces) {
+                    if (!newToken || ns.statements.find((s) => (0, reflection_1.isClassStatement)(s))) {
+                        if (!result.has(ns.lastPartName)) {
+                            result.set(ns.lastPartName, {
+                                label: ns.lastPartName,
+                                kind: vscode_languageserver_2.CompletionItemKind.Module
+                            });
+                        }
+                    }
+                }
+                //add function and class statement completions
+                for (let stmt of namespace.statements) {
+                    if ((0, reflection_1.isClassStatement)(stmt)) {
+                        result.set(stmt.name.text, {
+                            label: stmt.name.text,
+                            kind: vscode_languageserver_2.CompletionItemKind.Class
+                        });
+                    }
+                    else if ((0, reflection_1.isFunctionStatement)(stmt) && !newToken) {
+                        result.set(stmt.name.text, {
+                            label: stmt.name.text,
+                            kind: vscode_languageserver_2.CompletionItemKind.Function
+                        });
+                    }
+                    else if ((0, reflection_1.isEnumStatement)(stmt) && !newToken) {
+                        result.set(stmt.name, {
+                            label: stmt.name,
+                            kind: vscode_languageserver_2.CompletionItemKind.Enum
+                        });
+                    }
+                    else if ((0, reflection_1.isConstStatement)(stmt) && !newToken) {
+                        result.set(stmt.name, {
+                            label: stmt.name,
+                            kind: vscode_languageserver_2.CompletionItemKind.Constant
+                        });
+                    }
+                }
+            }
+        }
+        return [...result.values()];
     }
     /**
      * Given a current token, walk
@@ -627,9 +1004,6 @@ class BrsFile {
     }
     isPositionNextToTokenKind(position, tokenKind) {
         const closestToken = this.getClosestToken(position);
-        return this.isTokenNextToTokenKind(closestToken, tokenKind);
-    }
-    isTokenNextToTokenKind(closestToken, tokenKind) {
         const previousToken = this.getPreviousToken(closestToken);
         const previousTokenKind = previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind;
         //next to matched token
@@ -652,9 +1026,6 @@ class BrsFile {
     }
     getTokenBefore(currentToken, tokenKind) {
         const index = this.parser.tokens.indexOf(currentToken);
-        if (!tokenKind) {
-            return this.parser.tokens[index - 1];
-        }
         for (let i = index - 1; i >= 0; i--) {
             currentToken = this.parser.tokens[i];
             if (currentToken.kind === TokenKind_1.TokenKind.Newline) {
@@ -722,7 +1093,7 @@ class BrsFile {
                 let scopes = this.program.getScopesForFile(this);
                 for (let scope of scopes) {
                     let namespace = scope.namespaceLookup.get(namespaceName.toLowerCase());
-                    if (namespace.functionStatements.has(lowerCalleeName)) {
+                    if (namespace === null || namespace === void 0 ? void 0 : namespace.functionStatements[lowerCalleeName]) {
                         return true;
                     }
                 }
@@ -752,248 +1123,36 @@ class BrsFile {
     }
     /**
      * Builds a list of document symbols for this file. Used by LanguageServer's onDocumentSymbol functionality
+     * @deprecated use `DocumentSymbolProvider.process()` instead
      */
     getDocumentSymbols() {
-        if (this.documentSymbols) {
-            return this.documentSymbols;
-        }
-        let symbols = [];
-        for (const statement of this.ast.statements) {
-            const symbol = this.getDocumentSymbol(statement);
-            if (symbol) {
-                symbols.push(symbol);
-            }
-        }
-        this.documentSymbols = symbols;
-        return symbols;
+        return new DocumentSymbolProcessor_1.DocumentSymbolProcessor({
+            documentSymbols: [],
+            file: this,
+            program: this.program
+        }).process();
     }
     /**
      * Builds a list of workspace symbols for this file. Used by LanguageServer's onWorkspaceSymbol functionality
      */
     getWorkspaceSymbols() {
-        if (this.workspaceSymbols) {
-            return this.workspaceSymbols;
-        }
-        let symbols = [];
-        for (const statement of this.ast.statements) {
-            for (const symbol of this.generateWorkspaceSymbols(statement)) {
-                symbols.push(symbol);
-            }
-        }
-        this.workspaceSymbols = symbols;
-        return symbols;
-    }
-    /**
-     * Builds a single DocumentSymbol object for use by LanguageServer's onDocumentSymbol functionality
-     */
-    getDocumentSymbol(statement) {
-        let symbolKind;
-        const children = [];
-        if ((0, reflection_1.isFunctionStatement)(statement)) {
-            symbolKind = vscode_languageserver_2.SymbolKind.Function;
-        }
-        else if ((0, reflection_1.isMethodStatement)(statement)) {
-            symbolKind = vscode_languageserver_2.SymbolKind.Method;
-        }
-        else if ((0, reflection_1.isFieldStatement)(statement)) {
-            symbolKind = vscode_languageserver_2.SymbolKind.Field;
-        }
-        else if ((0, reflection_1.isNamespaceStatement)(statement)) {
-            symbolKind = vscode_languageserver_2.SymbolKind.Namespace;
-            for (const childStatement of statement.body.statements) {
-                const symbol = this.getDocumentSymbol(childStatement);
-                if (symbol) {
-                    children.push(symbol);
-                }
-            }
-        }
-        else if ((0, reflection_1.isClassStatement)(statement)) {
-            symbolKind = vscode_languageserver_2.SymbolKind.Class;
-            for (const childStatement of statement.body) {
-                const symbol = this.getDocumentSymbol(childStatement);
-                if (symbol) {
-                    children.push(symbol);
-                }
-            }
-        }
-        else {
-            return;
-        }
-        const name = (0, reflection_1.isFieldStatement)(statement) ? statement.name.text : statement.getName(Parser_1.ParseMode.BrighterScript);
-        return vscode_languageserver_2.DocumentSymbol.create(name, '', symbolKind, statement.range, statement.range, children);
-    }
-    /**
-     * Builds a single SymbolInformation object for use by LanguageServer's onWorkspaceSymbol functionality
-     */
-    generateWorkspaceSymbols(statement, containerStatement) {
-        let symbolKind;
-        const symbols = [];
-        if ((0, reflection_1.isFunctionStatement)(statement)) {
-            symbolKind = vscode_languageserver_2.SymbolKind.Function;
-        }
-        else if ((0, reflection_1.isMethodStatement)(statement)) {
-            symbolKind = vscode_languageserver_2.SymbolKind.Method;
-        }
-        else if ((0, reflection_1.isNamespaceStatement)(statement)) {
-            symbolKind = vscode_languageserver_2.SymbolKind.Namespace;
-            for (const childStatement of statement.body.statements) {
-                for (const symbol of this.generateWorkspaceSymbols(childStatement, statement)) {
-                    symbols.push(symbol);
-                }
-            }
-        }
-        else if ((0, reflection_1.isClassStatement)(statement)) {
-            symbolKind = vscode_languageserver_2.SymbolKind.Class;
-            for (const childStatement of statement.body) {
-                for (const symbol of this.generateWorkspaceSymbols(childStatement, statement)) {
-                    symbols.push(symbol);
-                }
-            }
-        }
-        else {
-            return symbols;
-        }
-        const name = statement.getName(Parser_1.ParseMode.BrighterScript);
-        const uri = util_1.util.pathToUri(this.srcPath);
-        const symbol = vscode_languageserver_2.SymbolInformation.create(name, symbolKind, statement.range, uri, containerStatement === null || containerStatement === void 0 ? void 0 : containerStatement.getName(Parser_1.ParseMode.BrighterScript));
-        symbols.push(symbol);
-        return symbols;
+        return new WorkspaceSymbolProcessor_1.WorkspaceSymbolProcessor({
+            program: this.program,
+            workspaceSymbols: []
+        }).process();
     }
     /**
      * Given a position in a file, if the position is sitting on some type of identifier,
      * go to the definition of that identifier (where this thing was first defined)
+     * @deprecated use `DefinitionProvider.process()` instead
      */
     getDefinition(position) {
-        var _a, _b;
-        let results = [];
-        //get the token at the position
-        const token = this.getTokenAt(position);
-        // While certain other tokens are allowed as local variables (AllowedLocalIdentifiers: https://github.com/rokucommunity/brighterscript/blob/master/src/lexer/TokenKind.ts#L418), these are converted by the parser to TokenKind.Identifier by the time we retrieve the token using getTokenAt
-        let definitionTokenTypes = [
-            TokenKind_1.TokenKind.Identifier,
-            TokenKind_1.TokenKind.StringLiteral
-        ];
-        //throw out invalid tokens and the wrong kind of tokens
-        if (!token || !definitionTokenTypes.includes(token.kind)) {
-            return results;
-        }
-        const scopesForFile = this.program.getScopesForFile(this);
-        const [scope] = scopesForFile;
-        const expression = this.getClosestExpression(position);
-        if (scope && expression) {
-            scope.linkSymbolTable();
-            let containingNamespace = (_a = expression.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript);
-            const fullName = (_b = util_1.util.getAllDottedGetParts(expression)) === null || _b === void 0 ? void 0 : _b.map(x => x.text).join('.');
-            //find a constant with this name
-            const constant = scope === null || scope === void 0 ? void 0 : scope.getConstFileLink(fullName, containingNamespace);
-            if (constant) {
-                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) || (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));
-                    return results;
-                }
-                const enumMemberLink = scope.getEnumMemberFileLink(fullName, containingNamespace);
-                if (enumMemberLink) {
-                    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();
-        const previousToken = this.getTokenAt({ line: token.range.start.line, character: token.range.start.character });
-        if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind) === TokenKind_1.TokenKind.Callfunc) {
-            for (const scope of scopesForFile) {
-                //to only get functions defined in interface methods
-                const callable = scope.getAllCallables().find((c) => c.callable.name.toLowerCase() === textToSearchFor); // eslint-disable-line @typescript-eslint/no-loop-func
-                if (callable) {
-                    results.push(util_1.util.createLocation(util_1.util.pathToUri(callable.callable.file.srcPath), callable.callable.functionStatement.range));
-                }
-            }
-            return results;
-        }
-        let classToken = this.getTokenBefore(token, TokenKind_1.TokenKind.Class);
-        if (classToken) {
-            let cs = this.parser.references.classStatements.find((cs) => cs.classKeyword.range === classToken.range);
-            if (cs === null || cs === void 0 ? void 0 : cs.parentClassName) {
-                const nameParts = cs.parentClassName.getNameParts();
-                let extendedClass = this.getClassFileLink(nameParts[nameParts.length - 1], nameParts.slice(0, -1).join('.'));
-                if (extendedClass) {
-                    results.push(util_1.util.createLocation(util_1.util.pathToUri(extendedClass.file.srcPath), extendedClass.item.range));
-                }
-            }
-            return results;
-        }
-        if (token.kind === TokenKind_1.TokenKind.StringLiteral) {
-            // We need to strip off the quotes but only if present
-            const startIndex = textToSearchFor.startsWith('"') ? 1 : 0;
-            let endIndex = textToSearchFor.length;
-            if (textToSearchFor.endsWith('"')) {
-                endIndex--;
-            }
-            textToSearchFor = textToSearchFor.substring(startIndex, endIndex);
-        }
-        //look through local variables first, get the function scope for this position (if it exists)
-        const functionScope = this.getFunctionScopeAtPosition(position);
-        if (functionScope) {
-            //find any variable or label with this name
-            for (const varDeclaration of functionScope.variableDeclarations) {
-                //we found a variable declaration with this token text!
-                if (varDeclaration.name.toLowerCase() === textToSearchFor) {
-                    const uri = util_1.util.pathToUri(this.srcPath);
-                    results.push(util_1.util.createLocation(uri, varDeclaration.nameRange));
-                }
-            }
-            if (this.tokenFollows(token, TokenKind_1.TokenKind.Goto)) {
-                for (const label of functionScope.labelStatements) {
-                    if (label.name.toLocaleLowerCase() === textToSearchFor) {
-                        const uri = util_1.util.pathToUri(this.srcPath);
-                        results.push(util_1.util.createLocation(uri, label.nameRange));
-                    }
-                }
-            }
-        }
-        const filesSearched = new Set();
-        //look through all files in scope for matches
-        for (const scope of scopesForFile) {
-            for (const file of scope.getAllFiles()) {
-                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
-                    });
-                }
-            }
-        }
-        return results;
+        return new DefinitionProvider_1.DefinitionProvider({
+            program: this.program,
+            file: this,
+            position: position,
+            definitions: []
+        }).process();
     }
     getClassMemberDefinitions(textToSearchFor, file) {
         let results = [];
@@ -1009,8 +1168,8 @@ class BrsFile {
             }
         };
         file.parser.ast.walk((0, visitors_1.createVisitor)({
-            MethodStatement: statementHandler,
-            FieldStatement: fieldStatementHandler
+            ClassMethodStatement: statementHandler,
+            ClassFieldStatement: fieldStatementHandler
         }), {
             walkMode: visitors_1.WalkMode.visitStatements
         });
@@ -1044,58 +1203,27 @@ class BrsFile {
         }
         return statement;
     }
-    getReferences(position) {
-        const callSiteToken = this.getTokenAt(position);
-        let locations = [];
-        const searchFor = callSiteToken.text.toLowerCase();
-        const scopes = this.program.getScopesForFile(this);
-        for (const scope of scopes) {
-            const processedFiles = new Set();
-            for (const file of scope.getAllFiles()) {
-                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
-                    });
-                }
-            }
-        }
-        return locations;
-    }
     /**
-     * Generate the code, map, and typedef for this file
+     * Given a position in a file, if the position is sitting on some type of identifier,
+     * look up all references of that identifier (every place that identifier is used across the whole app)
+     * @deprecated use `ReferencesProvider.process()` instead
      */
-    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;
+    getReferences(position) {
+        return new ReferencesProvider_1.ReferencesProvider({
+            program: this.program,
+            file: this,
+            position: position,
+            references: []
+        }).process();
     }
     /**
      * 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));
+            transpileResult = util_1.util.sourceNodeFromTranspileResult(null, null, state.srcPath, this.ast.transpile(state));
         }
         else if (this.program.options.sourceMap) {
             //emit code as-is with a simple map to the original file location
@@ -1105,17 +1233,15 @@ 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);
         }
-        //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();
-        }
+        //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, [
+            const stagingFileName = path.basename(state.srcPath).replace(/\.bs$/, '.brs');
+            return new source_map_1.SourceNode(null, null, stagingFileName, [
                 transpileResult,
                 //add the sourcemap reference comment
-                `'//# sourceMappingURL=./${path.basename(state.srcPath)}.map`
-            ]).toStringWithSourceMap();
+                state.newline + `'//# sourceMappingURL=./${stagingFileName}.map`
+            ]).toStringWithSourceMap({ file: stagingFileName });
         }
         else {
             return {
@@ -1124,210 +1250,17 @@ 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);
-        const programNode = new source_map_1.SourceNode(null, null, this.srcPath, typedef);
+        const programNode = util_1.util.sourceNodeFromTranspileResult(null, null, this.srcPath, typedef);
         return programNode.toString();
     }
     dispose() {
-        var _a;
+        var _a, _b;
         (_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;
@@ -1338,4 +1271,18 @@ class BrsFile {
     }
 }
 exports.BrsFile = BrsFile;
+/**
+ * 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_2.CompletionItemKind.Keyword
+    };
+});
 //# sourceMappingURL=BrsFile.js.map