brighterscript 1.0.0-alpha.23 → 1.0.0-alpha.25

package/dist/files/BrsFile.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeywordCompletions = exports.BrsFile = void 0;
+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");
 const chalk_1 = require("chalk");
 const path = require("path");
 const DiagnosticMessages_1 = require("../DiagnosticMessages");
-const Token_1 = require("../lexer/Token");
+const FunctionScope_1 = require("../FunctionScope");
 const Lexer_1 = require("../lexer/Lexer");
 const TokenKind_1 = require("../lexer/TokenKind");
 const Parser_1 = require("../parser/Parser");
@@ -19,26 +20,18 @@ 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 BscType_1 = require("../types/BscType");
-const UninitializedType_1 = require("../types/UninitializedType");
-const InvalidType_1 = require("../types/InvalidType");
+const vscode_uri_1 = require("vscode-uri");
+const SymbolTable_1 = require("../SymbolTable");
+const Editor_1 = require("../astUtils/Editor");
+const AstValidationSegmenter_1 = require("../AstValidationSegmenter");
+const CachedLookups_1 = require("../astUtils/CachedLookups");
 /**
  * Holds all details about this file within the scope of the whole program
  */
 class BrsFile {
-    constructor(
-    /**
-     * The absolute path to the source file on disk (e.g. '/usr/you/projects/RokuApp/source/main.brs' or 'c:/projects/RokuApp/source/main.brs').
-     */
-    srcPath, 
-    /**
-     * The full pkg path (i.e. `pkg:/path/to/file.brs`)
-     */
-    pkgPath, program) {
-        var _a, _b;
-        this.srcPath = srcPath;
-        this.pkgPath = pkgPath;
-        this.program = program;
+    constructor(options) {
+        var _a, _b, _c;
+        this.type = 'BrsFile';
         /**
          * The parseMode used for the parser for this file
          */
@@ -48,64 +41,103 @@ class BrsFile {
          * Files are only ever validated a single time
          */
         this.isValidated = false;
-        this.diagnostics = [];
-        this.commentFlags = [];
-        this.callables = [];
-        this.functionCalls = [];
         /**
-         * Does this file need to be transpiled?
+         * A collection of diagnostics related to this file
          */
-        this.needsTranspiled = false;
-        this.srcPath = (0, util_1.standardizePath) `${this.srcPath}`;
-        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.typedefSrcPath = 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.diagnostics = [];
+        this.commentFlags = [];
+        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._cachedLookups = new CachedLookups_1.CachedLookups(this);
+            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();
+            }
         }
     }
     /**
-     * The absolute path to the source location for this file
-     * @deprecated use `srcPath` instead
+     * 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 pathAbsolute() {
-        return this.srcPath;
-    }
-    set pathAbsolute(value) {
-        this.srcPath = value;
+    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;
     }
+    /**
+     * @deprecated use `.diagnostics` instead
+     */
     getDiagnostics() {
-        return [...this.diagnostics];
+        return this.diagnostics;
+    }
+    addDiagnostic(diagnostic) {
+        if (!diagnostic.file) {
+            diagnostic.file = this;
+        }
+        this.diagnostics.push(diagnostic);
     }
     addDiagnostics(diagnostics) {
         this.diagnostics.push(...diagnostics);
     }
+    get functionScopes() {
+        if (!this._functionScopes) {
+            this.createFunctionScopes();
+        }
+        return this._functionScopes;
+    }
+    get cache() {
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        return this._cachedLookups['cache'];
+    }
     /**
      * files referenced by import statements
      */
     get ownScriptImports() {
         var _a, _b;
-        // eslint-disable-next-line @typescript-eslint/dot-notation
-        const result = (_b = (_a = this._parser) === null || _a === void 0 ? void 0 : _a.references['cache'].getOrAdd('BrsFile_ownScriptImports', () => {
-            var _a, _b, _c, _d;
+        const result = (_b = (_a = this.cache) === null || _a === void 0 ? void 0 : _a.getOrAdd('BrsFile_ownScriptImports', () => {
+            var _a, _b, _c;
             const result = [];
-            for (const statement of (_c = (_b = (_a = this.parser) === null || _a === void 0 ? void 0 : _a.references) === null || _b === void 0 ? void 0 : _b.importStatements) !== null && _c !== void 0 ? _c : []) {
+            for (const statement of (_b = (_a = this._cachedLookups) === null || _a === void 0 ? void 0 : _a.importStatements) !== null && _b !== void 0 ? _b : []) {
                 //register import statements
                 if ((0, reflection_1.isImportStatement)(statement) && statement.filePathToken) {
                     result.push({
                         filePathRange: statement.filePathToken.range,
-                        pkgPath: util_1.util.getPkgPathFromTarget(this.pkgPath, statement.filePath),
+                        destPath: util_1.util.getPkgPathFromTarget(this.destPath, statement.filePath),
                         sourceFile: this,
-                        text: (_d = statement.filePathToken) === null || _d === void 0 ? void 0 : _d.text
+                        text: (_c = statement.filePathToken) === null || _c === void 0 ? void 0 : _c.text
                     });
                 }
             }
@@ -113,11 +145,59 @@ class BrsFile {
         })) !== null && _b !== void 0 ? _b : [];
         return result;
     }
+    /**
+     * Does this file need to be transpiled?
+     * @deprecated use the `.editor` property to push changes to the file, which will force transpilation
+     */
+    get needsTranspiled() {
+        var _a, _b, _c, _d;
+        if (this._needsTranspiled !== undefined) {
+            return this._needsTranspiled;
+        }
+        return !!(((_a = this.extension) === null || _a === void 0 ? void 0 : _a.endsWith('.bs')) || ((_c = (_b = this.program) === null || _b === void 0 ? void 0 : _b.options) === null || _c === void 0 ? void 0 : _c.allowBrighterScriptInBrightScript) || ((_d = this.editor) === null || _d === void 0 ? void 0 : _d.hasChanges));
+    }
+    set needsTranspiled(value) {
+        this._needsTranspiled = value;
+    }
     /**
      * The AST for this file
      */
     get ast() {
-        return this.parser.ast;
+        var _a;
+        return (_a = this.parser) === null || _a === void 0 ? void 0 : _a.ast;
+    }
+    /**
+     * Get the token at the specified position
+     */
+    getTokenAt(position) {
+        for (let token of this.parser.tokens) {
+            if (util_1.util.rangeContains(token.range, position)) {
+                return token;
+            }
+        }
+    }
+    /**
+     * Walk the AST and find the expression that this token is most specifically contained within
+     */
+    getClosestExpression(position) {
+        const handle = new vscode_languageserver_1.CancellationTokenSource();
+        let containingNode;
+        this.ast.walk((node) => {
+            const latestContainer = containingNode;
+            //bsc walks depth-first
+            if (util_1.util.rangeContains(node.range, position)) {
+                containingNode = node;
+            }
+            //we had a match before, and don't now. this means we've finished walking down the whole way, and found our match
+            if (latestContainer && !containingNode) {
+                containingNode = latestContainer;
+                handle.cancel();
+            }
+        }, {
+            walkMode: visitors_1.WalkMode.visitAllRecursive,
+            cancel: handle.token
+        });
+        return containingNode;
     }
     get parser() {
         if (!this._parser) {
@@ -135,38 +215,32 @@ class BrsFile {
      * Find and set the typedef variables (if a matching typedef file exists)
      */
     resolveTypedef() {
-        this.typedefFile = this.program.getFile(this.typedefSrcPath);
+        this.typedefFile = this.program.getFile(this.typedefKey);
         this.hasTypedef = !!this.typedefFile;
     }
+    onDependenciesChanged() {
+        this.resolveTypedef();
+    }
     /**
      * Attach the file to the dependency graph so it can monitor changes.
      * Also notify the dependency graph of our current dependencies so other dependents can be notified.
+     * @deprecated this does nothing. This functionality is now handled by the file api and will be deleted in v1
      */
-    attachDependencyGraph(dependencyGraph) {
-        var _a;
-        (_a = this.unsubscribeFromDependencyGraph) === null || _a === void 0 ? void 0 : _a.call(this);
-        //event that fires anytime a dependency changes
-        this.unsubscribeFromDependencyGraph = dependencyGraph.onchange(this.dependencyGraphKey, () => {
-            this.resolveTypedef();
-        });
-        const dependencies = this.ownScriptImports.filter(x => !!x.pkgPath).map(x => x.pkgPath.toLowerCase());
+    attachDependencyGraph(dependencyGraph) { }
+    /**
+     * The list of files that this file depends on
+     */
+    get dependencies() {
+        const result = this.ownScriptImports.filter(x => !!x.destPath).map(x => x.destPath.toLowerCase());
         //if this is a .brs file, watch for typedef changes
         if (this.extension === '.brs') {
-            dependencies.push(util_1.util.getTypedefPath(this.pkgPath));
+            result.push(util_1.util.getTypedefPath(this.destPath));
         }
-        dependencyGraph.addOrReplace(this.dependencyGraphKey, dependencies);
-    }
-    get logger() {
-        var _a;
-        const logger = (_a = this.program) === null || _a === void 0 ? void 0 : _a.logger;
-        if (!logger && !this._logger) {
-            this._logger = new Logger_1.Logger();
-        }
-        return logger !== null && logger !== void 0 ? logger : this._logger;
+        return result;
     }
     /**
      * Calculate the AST for this file
-     * @param fileContents
+     * @param fileContents the raw source code to parse
      */
     parse(fileContents) {
         try {
@@ -179,7 +253,7 @@ class BrsFile {
                 return;
             }
             //tokenize the input file
-            let lexer = this.logger.time(Logger_1.LogLevel.debug, ['lexer.lex', chalk_1.default.green(this.srcPath)], () => {
+            let lexer = this.program.logger.time(Logger_1.LogLevel.debug, ['lexer.lex', chalk_1.default.green(this.srcPath)], () => {
                 return Lexer_1.Lexer.scan(fileContents, {
                     includeWhitespace: false
                 });
@@ -190,7 +264,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.logger.time(Logger_1.LogLevel.debug, ['preprocessor.process', chalk_1.default.green(this.srcPath)], () => {
+                this.program.logger.time(Logger_1.LogLevel.debug, ['preprocessor.process', chalk_1.default.green(this.srcPath)], () => {
                     preprocessor.process(lexer.tokens, this.program.getManifest());
                 });
             }
@@ -202,18 +276,14 @@ class BrsFile {
             }
             //if the preprocessor generated tokens, use them.
             let tokens = preprocessor.processedTokens.length > 0 ? preprocessor.processedTokens : lexer.tokens;
-            this.logger.time(Logger_1.LogLevel.debug, ['parser.parse', chalk_1.default.green(this.srcPath)], () => {
+            this.program.logger.time(Logger_1.LogLevel.debug, ['parser.parse', chalk_1.default.green(this.srcPath)], () => {
                 this._parser = Parser_1.Parser.parse(tokens, {
                     mode: this.parseMode,
-                    logger: this.logger
+                    logger: this.program.logger
                 });
             });
             //absorb all lexing/preprocessing/parsing diagnostics
             this.diagnostics.push(...lexer.diagnostics, ...preprocessor.diagnostics, ...this._parser.diagnostics);
-            //extract all callables from this file
-            this.findCallables();
-            //find all places where a sub/function is being called
-            this.findFunctionCalls();
             //attach this file to every diagnostic
             for (let diagnostic of this.diagnostics) {
                 diagnostic.file = this;
@@ -224,45 +294,6 @@ 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)))));
         }
     }
-    validate() {
-        //only validate the file if it was actually parsed (skip files containing typedefs)
-        if (!this.hasTypedef) {
-            this.validateImportStatements();
-        }
-    }
-    validateImportStatements() {
-        let topOfFileIncludeStatements = [];
-        for (let stmt of this.ast.statements) {
-            //skip comments
-            if ((0, reflection_1.isCommentStatement)(stmt)) {
-                continue;
-            }
-            //if we found a non-library statement, this statement is not at the top of the file
-            if ((0, reflection_1.isLibraryStatement)(stmt) || (0, reflection_1.isImportStatement)(stmt)) {
-                topOfFileIncludeStatements.push(stmt);
-            }
-            else {
-                //break out of the loop, we found all of our library statements
-                break;
-            }
-        }
-        let statements = [
-            ...this._parser.references.libraryStatements,
-            ...this._parser.references.importStatements
-        ];
-        for (let result of statements) {
-            //if this statement is not one of the top-of-file statements,
-            //then add a diagnostic explaining that it is invalid
-            if (!topOfFileIncludeStatements.includes(result)) {
-                if ((0, reflection_1.isLibraryStatement)(result)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.libraryStatementMustBeDeclaredAtTopOfFile()), { range: result.range, file: this }));
-                }
-                else if ((0, reflection_1.isImportStatement)(result)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.importStatementMustBeDeclaredAtTopOfFile()), { range: result.range, file: this }));
-                }
-            }
-        }
-    }
     /**
      * Find a class. This scans all scopes for this file, and returns the first matching class that is found.
      * Returns undefined if not found.
@@ -284,12 +315,12 @@ class BrsFile {
     }
     findPropertyNameCompletions() {
         //Build completion items from all the "properties" found in the file
-        const { propertyHints } = this.parser.references;
+        const { propertyHints } = this._cachedLookups;
         const results = [];
         for (const key of Object.keys(propertyHints)) {
             results.push({
                 label: propertyHints[key],
-                kind: vscode_languageserver_1.CompletionItemKind.Text
+                kind: vscode_languageserver_2.CompletionItemKind.Text
             });
         }
         return results;
@@ -302,7 +333,7 @@ class BrsFile {
     }
     /**
      * Find all comment flags in the source code. These enable or disable diagnostic messages.
-     * @param lines - the lines of the program
+     * @param tokens - an array of tokens of which to find `TokenKind.Comment` from
      */
     getCommentFlags(tokens) {
         const processor = new CommentFlagProcessor_1.CommentFlagProcessor(this, ['rem', `'`], DiagnosticMessages_1.diagnosticCodes, [DiagnosticMessages_1.DiagnosticCodeMap.unknownDiagnosticCode]);
@@ -315,738 +346,250 @@ class BrsFile {
         this.commentFlags.push(...processor.commentFlags);
         this.diagnostics.push(...processor.diagnostics);
     }
-    findCallables() {
+    /**
+     * Create a scope for every function in this file
+     */
+    createFunctionScopes() {
         var _a;
-        for (let statement of (_a = this.parser.references.functionStatements) !== null && _a !== void 0 ? _a : []) {
-            let functionType = statement.func.getFunctionType();
-            functionType.setName(statement.name.text);
-            this.callables.push({
-                isSub: statement.func.functionType.text.toLowerCase() === 'sub',
-                name: statement.name.text,
-                nameRange: statement.name.range,
-                file: this,
-                params: functionType.params,
-                range: statement.func.range,
-                type: functionType,
-                getName: statement.getName.bind(statement),
-                hasNamespace: !!statement.namespaceName,
-                functionStatement: statement
+        //find every function
+        let functions = this._cachedLookups.functionExpressions;
+        //create a functionScope for every function
+        this._functionScopes = [];
+        for (let func of functions) {
+            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));
+                //add this child scope to its parent
+                if (parentScope) {
+                    parentScope.childrenScopes.push(scope);
+                }
+                //store the parent scope for this scope
+                scope.parentScope = parentScope;
+            }
+            //add every parameter
+            for (let param of func.parameters) {
+                scope.variableDeclarations.push({
+                    nameRange: param.name.range,
+                    lineIndex: param.name.range.start.line,
+                    name: param.name.text,
+                    getType: () => {
+                        return param.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+                    }
+                });
+            }
+            //add all of ForEachStatement loop varibales
+            (_a = func.body) === null || _a === void 0 ? void 0 : _a.walk((0, visitors_1.createVisitor)({
+                ForEachStatement: (stmt) => {
+                    scope.variableDeclarations.push({
+                        nameRange: stmt.item.range,
+                        lineIndex: stmt.item.range.start.line,
+                        name: stmt.item.text,
+                        getType: () => DynamicType_1.DynamicType.instance //TODO: Infer types from array
+                    });
+                },
+                LabelStatement: (stmt) => {
+                    const { identifier } = stmt.tokens;
+                    scope.labelStatements.push({
+                        nameRange: identifier.range,
+                        lineIndex: identifier.range.start.line,
+                        name: identifier.text
+                    });
+                }
+            }), {
+                walkMode: visitors_1.WalkMode.visitStatements
             });
+            this.scopesByFunc.set(func, scope);
+            //find every statement in the scope
+            this._functionScopes.push(scope);
+        }
+        //find every variable assignment in the whole file
+        let assignmentStatements = this._cachedLookups.assignmentStatements;
+        for (let statement of assignmentStatements) {
+            //find this statement's function scope
+            let scope = this.scopesByFunc.get(statement.findAncestor(reflection_1.isFunctionExpression));
+            //skip variable declarations that are outside of any scope
+            if (scope) {
+                scope.variableDeclarations.push({
+                    nameRange: statement.name.range,
+                    lineIndex: statement.name.range.start.line,
+                    name: statement.name.text,
+                    getType: () => {
+                        return statement.getType({ flags: SymbolTable_1.SymbolTypeFlag.runtime });
+                    }
+                });
+            }
         }
     }
-    findFunctionCalls() {
-        var _a;
-        this.functionCalls = [];
-        //for every function in the file
-        for (let func of this._parser.references.functionExpressions) {
-            //for all function calls in this function
-            for (let expression of func.callExpressions) {
-                if (
-                //filter out method calls on method calls for now (i.e. getSomething().getSomethingElse())
-                expression.callee.callee ||
-                    //filter out method calls on regexp literals for now
-                    (0, reflection_1.isRegexLiteralExpression)((_a = expression.callee) === null || _a === void 0 ? void 0 : _a.obj) ||
-                    //filter out callees without a name (immediately-invoked function expressions)
-                    !expression.callee.name) {
-                    continue;
+    get callables() {
+        if (this.staticCallables) {
+            // globalFile can statically set the callables
+            return this.staticCallables;
+        }
+        return this.cache.getOrAdd(`BrsFile_callables`, () => {
+            var _a, _b, _c, _d;
+            const callables = [];
+            for (let statement of (_a = this._cachedLookups.functionStatements) !== null && _a !== void 0 ? _a : []) {
+                //extract the parameters
+                let params = [];
+                for (let param of statement.func.parameters) {
+                    const paramType = param.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+                    let callableParam = {
+                        name: (_b = param.name) === null || _b === void 0 ? void 0 : _b.text,
+                        type: paramType,
+                        isOptional: !!param.defaultValue,
+                        isRestArgument: false
+                    };
+                    params.push(callableParam);
                 }
-                //Flag dotted function invocations (i.e. object.doSomething())
-                const dottedInvocation = expression.callee.obj;
-                let functionName = expression.callee.name;
-                //callee is the name of the function being called
-                let callee = expression.callee;
-                let columnIndexBegin = callee.range.start.character;
-                let columnIndexEnd = callee.range.end.character;
-                let args = [];
-                //TODO convert if stmts to use instanceof instead
-                for (let arg of expression.args) {
-                    let inferredType = (0, Parser_1.getBscTypeFromExpression)(arg, func);
-                    let argText = '';
-                    // Get the text to display for the arg
-                    if (arg.token) {
-                        argText = arg.token.text;
-                        //is a function call being passed into argument
+                const funcType = statement.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+                callables.push({
+                    isSub: statement.func.functionType.text.toLowerCase() === 'sub',
+                    name: (_c = statement.name) === null || _c === void 0 ? void 0 : _c.text,
+                    nameRange: (_d = statement.name) === null || _d === void 0 ? void 0 : _d.range,
+                    file: this,
+                    params: params,
+                    range: statement.func.range,
+                    type: funcType,
+                    getName: statement.getName.bind(statement),
+                    hasNamespace: !!statement.findAncestor(reflection_1.isNamespaceStatement),
+                    functionStatement: statement
+                });
+            }
+            return callables;
+        });
+    }
+    get functionCalls() {
+        return this.cache.getOrAdd(`BrsFile_functionCalls`, () => {
+            const functionCalls = [];
+            //for every function in the file
+            for (let func of this._cachedLookups.functionExpressions) {
+                //for all function calls in this function
+                for (let expression of func.callExpressions) {
+                    if (
+                    //filter out dotted function invocations (i.e. object.doSomething()) (not currently supported. TODO support it)
+                    expression.callee.obj ||
+                        //filter out method calls on method calls for now (i.e. getSomething().getSomethingElse())
+                        expression.callee.callee ||
+                        //filter out callees without a name (immediately-invoked function expressions)
+                        !expression.callee.name) {
+                        continue;
                     }
-                    else if (arg.name) {
-                        if ((0, Token_1.isToken)(arg.name)) {
-                            argText = arg.name.text;
+                    let functionName = expression.callee.name.text;
+                    //callee is the name of the function being called
+                    let callee = expression.callee;
+                    let columnIndexBegin = callee.range.start.character;
+                    let columnIndexEnd = callee.range.end.character;
+                    let args = [];
+                    //TODO convert if stmts to use instanceof instead
+                    for (let arg of expression.args) {
+                        //is a literal parameter value
+                        if ((0, reflection_1.isLiteralExpression)(arg)) {
+                            args.push({
+                                range: arg.range,
+                                type: arg.getType(),
+                                text: arg.token.text,
+                                expression: arg,
+                                typeToken: undefined
+                            });
+                            //is variable being passed into argument
                         }
-                    }
-                    else if (arg.value) {
-                        /* istanbul ignore next: TODO figure out why value is undefined sometimes */
-                        if (arg.value.value) {
-                            if (arg.value.value.toString) {
-                                argText = arg.value.value.toString();
+                        else if (arg.name) {
+                            args.push({
+                                range: arg.range,
+                                //TODO - look up the data type of the actual variable
+                                type: new DynamicType_1.DynamicType(),
+                                text: arg.name.text,
+                                expression: arg,
+                                typeToken: undefined
+                            });
+                        }
+                        else if (arg.value) {
+                            let text = '';
+                            /* istanbul ignore next: TODO figure out why value is undefined sometimes */
+                            if (arg.value.value) {
+                                text = arg.value.value.toString();
                             }
+                            let callableArg = {
+                                range: arg.range,
+                                //TODO not sure what to do here
+                                type: new DynamicType_1.DynamicType(),
+                                text: text,
+                                expression: arg,
+                                typeToken: undefined
+                            };
+                            //wrap the value in quotes because that's how it appears in the code
+                            if ((0, reflection_1.isStringType)(callableArg.type)) {
+                                callableArg.text = '"' + callableArg.text + '"';
+                            }
+                            args.push(callableArg);
                         }
-                        //wrap the value in quotes because that's how it appears in the code
-                        if (argText && (0, reflection_1.isStringType)(inferredType)) {
-                            argText = '"' + argText + '"';
+                        else {
+                            args.push({
+                                range: arg.range,
+                                type: new DynamicType_1.DynamicType(),
+                                //TODO get text from other types of args
+                                text: '',
+                                expression: arg,
+                                typeToken: undefined
+                            });
                         }
                     }
-                    args.push({
-                        range: arg.range,
-                        type: inferredType,
-                        text: argText,
-                        expression: arg,
-                        typeToken: undefined
-                    });
+                    let functionCall = {
+                        range: expression.range,
+                        functionScope: this.getFunctionScopeAtPosition(callee.range.start),
+                        file: this,
+                        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
+                    };
+                    functionCalls.push(functionCall);
                 }
-                let functionCall = {
-                    range: util_1.util.createRangeFromPositions(expression.range.start, expression.closingParen.range.end),
-                    functionExpression: this.getFunctionExpressionAtPosition(callee.range.start),
-                    file: this,
-                    name: functionName,
-                    nameRange: util_1.util.createRange(callee.range.start.line, columnIndexBegin, callee.range.start.line, columnIndexEnd),
-                    args: args,
-                    isDottedInvocation: dottedInvocation
-                };
-                this.functionCalls.push(functionCall);
             }
-        }
+            return functionCalls;
+        });
     }
     /**
-     * Find the function expression at the given position.
+     * Find the function scope at the given position.
+     * @param position the position used to find the deepest scope that contains it
      */
-    getFunctionExpressionAtPosition(position, functionExpressions) {
-        if (!functionExpressions) {
-            functionExpressions = this.parser.references.functionExpressions;
+    getFunctionScopeAtPosition(position) {
+        return this.cache.getOrAdd(`functionScope-${position.line}:${position.character}`, () => {
+            return this._getFunctionScopeAtPosition(position, this.functionScopes);
+        });
+    }
+    _getFunctionScopeAtPosition(position, functionScopes) {
+        if (!functionScopes) {
+            functionScopes = this.functionScopes;
         }
-        for (let functionExpression of functionExpressions) {
-            if (util_1.util.rangeContains(functionExpression.range, position)) {
+        for (let scope of functionScopes) {
+            if (util_1.util.rangeContains(scope.range, position)) {
                 //see if any of that scope's children match the position also, and give them priority
-                let childFunc = this.getFunctionExpressionAtPosition(position, functionExpression.childFunctionExpressions);
-                if (childFunc) {
-                    return childFunc;
+                let childScope = this._getFunctionScopeAtPosition(position, scope.childrenScopes);
+                if (childScope) {
+                    return childScope;
                 }
                 else {
-                    return functionExpression;
+                    return scope;
                 }
             }
         }
     }
     /**
      * Find the NamespaceStatement enclosing the given position
-     * @param position
-     * @param functionScopes
      */
     getNamespaceStatementForPosition(position) {
         if (position) {
-            for (const statement of this.parser.references.namespaceStatements) {
-                if (util_1.util.rangeContains(statement.range, position)) {
-                    return statement;
-                }
-            }
-        }
-    }
-    /**
-     * Get completions available at the given cursor. This aggregates all values from this file and the current scope.
-     */
-    getCompletions(position, scope) {
-        var _a;
-        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.parser.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 pkgPath from this scope
-                for (const file of scope.getAllFiles()) {
-                    const pkgPath = `${fileProtocol}:/${file.pkgPath.replace('pkg:/', '')}`;
-                    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 [];
-            }
-        }
-        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 functionExpression = this.getFunctionExpressionAtPosition(position);
-        if (!functionExpression) {
-            //we aren't in any function scope, so return the keyword completions and namespaces
-            if (this.parser.getTokenBefore(currentToken, TokenKind_1.TokenKind.New)) {
-                // there's a new keyword, so only class types are viable here
-                return [...this.getGlobalClassStatementCompletions(currentToken, this.parseMode, scope)];
-            }
-            else {
-                return [
-                    ...exports.KeywordCompletions,
-                    ...this.getGlobalClassStatementCompletions(currentToken, this.parseMode, scope),
-                    ...namespaceCompletions,
-                    ...this.getNonNamespacedEnumStatementCompletions(currentToken, this.parseMode, scope),
-                    ...this.getGlobalInterfaceStatementCompletions(currentToken, this.parseMode, scope)
-                ];
-            }
-        }
-        const classNameCompletions = this.getGlobalClassStatementCompletions(currentToken, this.parseMode, scope);
-        const interfaceNameCompletions = this.getGlobalInterfaceStatementCompletions(currentToken, this.parseMode, scope);
-        const newToken = this.parser.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.parser.tokenFollows(currentToken, TokenKind_1.TokenKind.Goto)) {
-            return this.getLabelCompletion(functionExpression);
-        }
-        if (this.parser.isPositionNextToTokenKind(position, TokenKind_1.TokenKind.Dot)) {
-            const selfClassMemberCompletions = this.getClassMemberCompletions(position, currentToken, functionExpression, scope);
-            if (selfClassMemberCompletions.size > 0) {
-                return [...selfClassMemberCompletions.values()].filter((i) => i.label !== 'new');
-            }
-            const tokenLookup = this.getSymbolTypeFromToken(currentToken, functionExpression, scope);
-            if ((_a = tokenLookup.symbolContainer) === null || _a === void 0 ? void 0 : _a.memberTable) {
-                return this.getCompletionsFromSymbolTable(tokenLookup.symbolContainer.memberTable);
-            }
-            const foundClassLink = this.getClassFromTokenLookup(tokenLookup, scope);
-            if (!foundClassLink) {
-                //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 {
-            //include namespaces
-            result.push(...namespaceCompletions);
-            //include class names
-            result.push(...classNameCompletions);
-            //include interfaces
-            result.push(...interfaceNameCompletions);
-            //include enums
-            result.push(...this.getNonNamespacedEnumStatementCompletions(currentToken, this.parseMode, scope));
-            //include the global callables
-            result.push(...scope.getCallablesAsCompletions(this.parseMode));
-            //add `m` because that's always valid within a function
-            result.push({
-                label: 'm',
-                kind: vscode_languageserver_1.CompletionItemKind.Variable
-            });
-            names.m = true;
-            result.push(...exports.KeywordCompletions);
-            //include local variables
-            for (let symbol of functionExpression.symbolTable.getOwnSymbols()) {
-                const symbolNameLower = symbol.name.toLowerCase();
-                //skip duplicate variable names
-                if (names[symbolNameLower]) {
-                    continue;
-                }
-                names[symbolNameLower] = true;
-                // TODO TYPES (This may be a performance hit?)
-                // const foundType = getTypeFromContext(symbol.type, { scope: scope, file: this });
-                result.push({
-                    //TODO does this work?
-                    label: symbol.name,
-                    //TODO TYPES find type for local vars - SEE above
-                    kind: vscode_languageserver_1.CompletionItemKind.Variable
-                    // kind: isFunctionType(foundType) ? CompletionItemKind.Function : 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;
+            return this.cache.getOrAdd(`namespaceStatementForPosition-${position.line}:${position.character}`, () => {
+                for (const statement of this._cachedLookups.namespaceStatements) {
+                    if (util_1.util.rangeContains(statement.range, position)) {
+                        return statement;
                     }
-                    names[firstPart.toLowerCase()] = true;
-                    result.push({
-                        label: firstPart,
-                        kind: vscode_languageserver_1.CompletionItemKind.Module
-                    });
-                }
-            }
-        }
-        return result;
-    }
-    getCompletionsFromSymbolTable(symbolTable) {
-        return symbolTable.getAllSymbols().map(bscType => {
-            return {
-                label: bscType.name,
-                kind: (0, reflection_1.isTypedFunctionType)(bscType.type) ? vscode_languageserver_1.CompletionItemKind.Method : vscode_languageserver_1.CompletionItemKind.Field
-            };
-        });
-    }
-    getLabelCompletion(func) {
-        return func.labelStatements.map(label => ({
-            label: label.tokens.identifier.text,
-            kind: vscode_languageserver_1.CompletionItemKind.Reference
-        }));
-    }
-    getClassMemberCompletions(position, currentToken, functionExpression, scope) {
-        var _a, _b, _c, _d;
-        let classStatement = this.getClassFromToken(currentToken, functionExpression, scope);
-        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_1.CompletionItemKind.Field : vscode_languageserver_1.CompletionItemKind.Method
-                        });
-                    }
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Gets the class (if any) of a given token based on the scope
-     * @param currentToken token in question
-     * @param functionExpression current functionExpression
-     * @param scope the current scope
-     * @returns A fileLink of the ClassStatement, if it is a class, otherwise undefined
-     */
-    getClassFromToken(currentToken, functionExpression, scope) {
-        const tokenLookup = this.getSymbolTypeFromToken(currentToken, functionExpression, scope);
-        return this.getClassFromTokenLookup(tokenLookup, scope);
-    }
-    /**
-     * Gets the class (if any) of a given token based on the scope
-     * @param currentToken token in question
-     * @param functionExpression current functionExpression
-     * @param scope the current scope
-     * @returns A fileLink of the ClassStatement, if it is a class, otherwise undefined
-     */
-    getClassFromTokenLookup(tokenLookup, scope) {
-        const currentClass = tokenLookup === null || tokenLookup === void 0 ? void 0 : tokenLookup.symbolContainer;
-        if ((0, reflection_1.isClassStatement)(currentClass)) {
-            return { item: currentClass, file: this };
-        }
-        else if ((0, reflection_1.isCustomType)(currentClass)) {
-            const foundClass = scope.getClass(currentClass.name);
-            if (foundClass) {
-                return { item: foundClass, file: this };
-            }
-        }
-        return undefined;
-    }
-    findNamespaceFromTokenChain(originalTokenChain, scope) {
-        let namespaceTokens = [];
-        let startsWithNamespace = '';
-        let namespaceContainer;
-        let tokenChain = [...originalTokenChain];
-        while (tokenChain[0] && tokenChain[0].usage === Parser_1.TokenUsage.Direct) {
-            const namespaceNameToCheck = `${startsWithNamespace}${startsWithNamespace.length > 0 ? '.' : ''}${tokenChain[0].token.text}`.toLowerCase();
-            const foundNamespace = scope.namespaceLookup.get(namespaceNameToCheck);
-            if (foundNamespace) {
-                namespaceContainer = foundNamespace;
-                namespaceTokens.push(tokenChain[0].token);
-                startsWithNamespace = namespaceTokens.map(token => token.text).join('.');
-                tokenChain.shift();
-            }
-            else {
-                break;
-            }
-        }
-        if (namespaceTokens.length > 0) {
-            namespaceContainer = scope.namespaceLookup.get(startsWithNamespace.toLowerCase());
-        }
-        return { namespaceContainer: namespaceContainer, tokenChain: tokenChain };
-    }
-    checkForSpecialClassSymbol(currentToken, scope, func) {
-        var _a;
-        const containingClass = this.parser.getContainingClass(currentToken);
-        let symbolType;
-        let currentClassRef;
-        const currentTokenLower = currentToken.text.toLowerCase();
-        const typeContext = { file: this, scope: scope, position: currentToken.range.start };
-        if (containingClass) {
-            // Special cases for a single token inside a class
-            let expandedText = '';
-            let useExpandedTextOnly = false;
-            if (containingClass.name === currentToken) {
-                symbolType = containingClass.getThisBscType();
-                expandedText = `class ${containingClass.getName(Parser_1.ParseMode.BrighterScript)}`;
-                useExpandedTextOnly = true;
-                currentClassRef = containingClass;
-            }
-            else if (currentTokenLower === 'm') {
-                symbolType = containingClass.getThisBscType();
-                expandedText = currentToken.text;
-                currentClassRef = containingClass;
-            }
-            else if (currentTokenLower === 'super') {
-                symbolType = (0, BscType_1.getTypeFromContext)(containingClass.symbolTable.getSymbolType(currentTokenLower, true, typeContext), typeContext);
-                if ((0, reflection_1.isTypedFunctionType)(symbolType)) {
-                    currentClassRef = scope.getParentClass(containingClass);
-                }
-            }
-            else if (((_a = func === null || func === void 0 ? void 0 : func.functionStatement) === null || _a === void 0 ? void 0 : _a.name) === currentToken) {
-                // check if this is a method declaration
-                currentClassRef = containingClass;
-                symbolType = containingClass === null || containingClass === void 0 ? void 0 : containingClass.memberTable.getSymbolType(currentTokenLower, true, { file: this, scope: scope });
-                expandedText = [containingClass.getName(Parser_1.ParseMode.BrighterScript), currentToken.text].join('.');
-            }
-            else if (!func) {
-                // check if this is a field  declaration
-                currentClassRef = containingClass;
-                symbolType = containingClass === null || containingClass === void 0 ? void 0 : containingClass.memberTable.getSymbolType(currentTokenLower, true, { file: this, scope: scope });
-                expandedText = [containingClass.getName(Parser_1.ParseMode.BrighterScript), currentToken.text].join('.');
-            }
-            if (symbolType) {
-                return { type: symbolType, expandedTokenText: expandedText, symbolContainer: currentClassRef, useExpandedTextOnly: useExpandedTextOnly };
-            }
-        }
-    }
-    checkForSpecialCaseToken(nameSpacedTokenChain, functionExpression, scope) {
-        var _a;
-        const tokenChain = (_a = nameSpacedTokenChain.tokenChain) !== null && _a !== void 0 ? _a : [];
-        if (nameSpacedTokenChain.namespaceContainer && tokenChain.length === 0) {
-            //currentToken was part of a namespace
-            return {
-                type: null,
-                expandedTokenText: `namespace ${nameSpacedTokenChain.namespaceContainer.fullName}`,
-                useExpandedTextOnly: true
-            };
-        }
-        const specialCase = tokenChain.length === 1 ? this.checkForSpecialClassSymbol(tokenChain[0].token, scope, functionExpression) : null;
-        if (specialCase) {
-            return specialCase;
-        }
-    }
-    /**
-     * Checks previous tokens for the start of a symbol chain (eg. m.property.subProperty.method())
-     * @param currentToken  The token to check
-     * @param functionExpression The current function context
-     * @param scope use this scope for finding class maps
-     * @returns the BscType, expanded text (e.g <Class.field>) and classStatement (if available) for the token
-     */
-    getSymbolTypeFromToken(currentToken, functionExpression, scope) {
-        var _a, _b, _c, _d;
-        if (!scope || !currentToken) {
-            return undefined;
-        }
-        const cachedSymbolData = scope.symbolCache.get(currentToken);
-        if (cachedSymbolData) {
-            return cachedSymbolData;
-        }
-        const tokenChainResponse = this.parser.getTokenChain(currentToken);
-        if (tokenChainResponse.includesUnknowableTokenType) {
-            const symbolData = { type: new DynamicType_1.DynamicType(), expandedTokenText: currentToken.text };
-            scope.symbolCache.set(currentToken, symbolData);
-            return symbolData;
-        }
-        const nameSpacedTokenChain = this.findNamespaceFromTokenChain(tokenChainResponse.chain, scope);
-        const specialCase = this.checkForSpecialCaseToken(nameSpacedTokenChain, functionExpression, scope);
-        if (specialCase) {
-            scope.symbolCache.set(currentToken, specialCase);
-            return specialCase;
-        }
-        const tokenChain = nameSpacedTokenChain.tokenChain;
-        let symbolContainer = this.parser.getContainingAA(currentToken) || this.parser.getContainingClass(currentToken);
-        let currentSymbolTable = (_b = (_a = nameSpacedTokenChain.namespaceContainer) === null || _a === void 0 ? void 0 : _a.symbolTable) !== null && _b !== void 0 ? _b : functionExpression === null || functionExpression === void 0 ? void 0 : functionExpression.symbolTable;
-        let tokenFoundCount = 0;
-        let symbolTypeBeforeReference;
-        let symbolType;
-        let tokenText = [];
-        let justReturnDynamic = false;
-        const typeContext = { file: this, scope: scope, position: (_c = tokenChain[0]) === null || _c === void 0 ? void 0 : _c.token.range.start };
-        for (const tokenChainMember of tokenChain) {
-            const token = tokenChainMember === null || tokenChainMember === void 0 ? void 0 : tokenChainMember.token;
-            const tokenUsage = tokenChainMember === null || tokenChainMember === void 0 ? void 0 : tokenChainMember.usage;
-            const tokenLowerText = token.text.toLowerCase();
-            if (tokenLowerText === 'super' && (0, reflection_1.isClassStatement)(symbolContainer) && tokenFoundCount === 0) {
-                /// Special cases for first item in chain inside a class
-                symbolContainer = scope === null || scope === void 0 ? void 0 : scope.getParentClass(symbolContainer);
-                currentSymbolTable = symbolContainer === null || symbolContainer === void 0 ? void 0 : symbolContainer.memberTable;
-                if (symbolContainer && currentSymbolTable) {
-                    tokenText.push(symbolContainer.getName(Parser_1.ParseMode.BrighterScript));
-                    tokenFoundCount++;
-                    continue;
                 }
-            }
-            if (!currentSymbolTable) {
-                // uh oh... no symbol table to continue to check
-                break;
-            }
-            symbolType = currentSymbolTable.getSymbolType(tokenLowerText, true, typeContext);
-            if (tokenFoundCount === 0 && !symbolType) {
-                //check for global callable
-                symbolType = (_d = scope.getGlobalCallableByName(tokenLowerText)) === null || _d === void 0 ? void 0 : _d.type;
-            }
-            if (symbolType) {
-                // found this symbol, and it's valid. increase found counter
-                tokenFoundCount++;
-            }
-            symbolTypeBeforeReference = symbolType;
-            if ((0, reflection_1.isTypedFunctionType)(symbolType)) {
-                // this is a function, and it is in the start or middle of the chain
-                // the next symbol to check will be the return value of this function
-                symbolType = (0, BscType_1.getTypeFromContext)(symbolType.returnType, typeContext);
-                if (tokenFoundCount < tokenChain.length) {
-                    // We still have more tokens, but remember the last known reference
-                    symbolTypeBeforeReference = symbolType;
-                }
-            }
-            if ((0, reflection_1.isArrayType)(symbolType) && tokenUsage === Parser_1.TokenUsage.ArrayReference) {
-                symbolType = (0, BscType_1.getTypeFromContext)(symbolType.getDefaultType(typeContext), typeContext);
-            }
-            if (symbolType === null || symbolType === void 0 ? void 0 : symbolType.memberTable) {
-                if ((0, reflection_1.isCustomType)(symbolType) || (0, reflection_1.isInterfaceType)(symbolType) || (0, reflection_1.isEnumType)(symbolType)) {
-                    // we're currently looking at a type that has its own symbol table
-                    // use the name of the custom type
-                    // TODO TYPES: get proper parent name for methods/fields defined in super classes
-                    tokenText.push(tokenChain.length === 1 ? token.text : symbolType.name);
-                }
-                else {
-                    justReturnDynamic = true;
-                    tokenText.push(token.text);
-                }
-                symbolContainer = symbolType;
-                currentSymbolTable = symbolContainer === null || symbolContainer === void 0 ? void 0 : symbolContainer.memberTable;
-            }
-            else if ((0, reflection_1.isObjectType)(symbolType) || (0, reflection_1.isArrayType)(symbolType) || (0, reflection_1.isDynamicType)(symbolType)) {
-                // this is an object that has no member table
-                // this could happen if a parameter is marked as object
-                // assume all fields are dynamic
-                symbolContainer = undefined;
-                tokenText.push(token.text);
-                justReturnDynamic = true;
-                break;
-            }
-            else {
-                // No further symbol tables were found
-                symbolContainer = undefined;
-                tokenText.push(token.text);
-                break;
-            }
-        }
-        if (tokenText.length > 2) {
-            // TokenText is used for hovers. We only need the last two tokens for a hover
-            // So in a long chain (e.g. klass.getData()[0].anotherKlass.property), the hover
-            // for the last token should just be "AnotherKlass.property", not the whole chain
-            tokenText = tokenText.slice(-2);
-        }
-        let expandedTokenText = tokenText.join('.');
-        let backUpReturnType;
-        if (tokenFoundCount === tokenChain.length) {
-            // did we complete the chain? if so, we have a valid token at the end
-            const symbolData = { type: symbolTypeBeforeReference, expandedTokenText: tokenText.join('.'), symbolContainer: symbolContainer };
-            scope.symbolCache.set(currentToken, symbolData);
-            return symbolData;
-        }
-        if ((0, reflection_1.isDynamicType)(symbolTypeBeforeReference) || (0, reflection_1.isArrayType)(symbolTypeBeforeReference) || justReturnDynamic) {
-            // last type in chain is dynamic... so currentToken could be anything.
-            backUpReturnType = new DynamicType_1.DynamicType();
-            expandedTokenText = currentToken.text;
-        }
-        else if ((0, reflection_1.isPrimitiveType)(symbolTypeBeforeReference)) {
-            // last type in chain is dynamic... so currentToken could be anything.
-            backUpReturnType = new DynamicType_1.DynamicType();
-            expandedTokenText = currentToken.text;
-        }
-        else if (tokenChain.length === 1) {
-            // variable that has not been assigned
-            expandedTokenText = currentToken.text;
-            backUpReturnType = new UninitializedType_1.UninitializedType();
-        }
-        else if (tokenFoundCount === tokenChain.length - 1) {
-            // member field that is not known
-            if (symbolContainer) {
-                backUpReturnType = new InvalidType_1.InvalidType();
-            }
-            else {
-                // TODO TYPES: once we have stricter object/node member type checking, we could say this is invalid, but until then, call it dynamic
-                backUpReturnType = new DynamicType_1.DynamicType();
-                expandedTokenText = currentToken.text;
-            }
-        }
-        const symbolData = { type: backUpReturnType, expandedTokenText: expandedTokenText };
-        scope.symbolCache.set(currentToken, symbolData);
-        return symbolData;
-    }
-    getGlobalClassStatementCompletions(currentToken, parseMode, scope) {
-        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 classMap = scope.getClassMap();
-        // let viableKeys = [...classMap.keys()].filter((k) => k.startsWith(completionName));
-        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_1.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_1.CompletionItemKind.Enum
-                });
-            }
-        }
-        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_1.CompletionItemKind.EnumMember
-                });
-            }
-        }
-        return [...results.values()];
-    }
-    getGlobalInterfaceStatementCompletions(currentToken, parseMode, scope) {
-        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 ifaceMap = scope.getInterfaceMap();
-        for (const key of [...ifaceMap.keys()]) {
-            let cs = ifaceMap.get(key).item;
-            if (!results.has(cs.name.text)) {
-                results.set(cs.name.text, {
-                    label: cs.name.text,
-                    kind: vscode_languageserver_1.CompletionItemKind.Interface
-                });
-            }
-        }
-        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.parser.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_1.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_1.CompletionItemKind.Class
-                        });
-                    }
-                    else if ((0, reflection_1.isFunctionStatement)(stmt) && !newToken) {
-                        result.set(stmt.name.text, {
-                            label: stmt.name.text,
-                            kind: vscode_languageserver_1.CompletionItemKind.Function
-                        });
-                    }
-                    else if ((0, reflection_1.isEnumStatement)(stmt) && !newToken) {
-                        result.set(stmt.name, {
-                            label: stmt.name,
-                            kind: vscode_languageserver_1.CompletionItemKind.Enum
-                        });
-                    }
-                }
-            }
+            });
         }
-        return [...result.values()];
     }
     getNamespaceDefinitions(token, file) {
         //BrightScript does not support namespaces, so return an empty list in that case
@@ -1062,7 +605,7 @@ class BrsFile {
                 const namespaceItemStatementHandler = (statement) => {
                     if (!location && statement.name.text.toLowerCase() === endName) {
                         const uri = util_1.util.pathToUri(file.srcPath);
-                        location = vscode_languageserver_1.Location.create(uri, statement.range);
+                        location = util_1.util.createLocation(uri, statement.range);
                     }
                 };
                 file.parser.ast.walk((0, visitors_1.createVisitor)({
@@ -1105,6 +648,70 @@ class BrsFile {
             return undefined;
         }
     }
+    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
+        if (!closestToken || closestToken.kind === TokenKind_1.TokenKind.Eof) {
+            return false;
+        }
+        else if (closestToken.kind === tokenKind) {
+            return true;
+        }
+        else if (closestToken.kind === TokenKind_1.TokenKind.Newline || previousTokenKind === TokenKind_1.TokenKind.Newline) {
+            return false;
+            //next to an identifier, which is next to token kind
+        }
+        else if (closestToken.kind === TokenKind_1.TokenKind.Identifier && previousTokenKind === tokenKind) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    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) {
+                break;
+            }
+            else if (currentToken.kind === tokenKind) {
+                return currentToken;
+            }
+        }
+        return undefined;
+    }
+    tokenFollows(currentToken, tokenKind) {
+        const index = this.parser.tokens.indexOf(currentToken);
+        if (index > 0) {
+            return this.parser.tokens[index - 1].kind === tokenKind;
+        }
+        return false;
+    }
+    getTokensUntil(currentToken, tokenKind, direction = -1) {
+        let tokens = [];
+        for (let i = this.parser.tokens.indexOf(currentToken); direction === -1 ? i >= 0 : i === this.parser.tokens.length; i += direction) {
+            currentToken = this.parser.tokens[i];
+            if (currentToken.kind === TokenKind_1.TokenKind.Newline || currentToken.kind === tokenKind) {
+                break;
+            }
+            tokens.push(currentToken);
+        }
+        return tokens;
+    }
+    getPreviousToken(token) {
+        const parser = this.parser;
+        let idx = parser.tokens.indexOf(token);
+        return parser.tokens[idx - 1];
+    }
     /**
      * Find the first scope that has a namespace with this name.
      * Returns false if no namespace was found with that name
@@ -1138,14 +745,60 @@ class BrsFile {
                 let scopes = this.program.getScopesForFile(this);
                 for (let scope of scopes) {
                     let namespace = scope.namespaceLookup.get(namespaceName.toLowerCase());
-                    if (namespace.functionStatements[lowerCalleeName]) {
+                    if (namespace.functionStatements.has(lowerCalleeName)) {
                         return true;
                     }
+                    if (namespace.classStatements.has(lowerCalleeName)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Determine if the callee (i.e. function name) is a known function
+     */
+    calleeIsKnownFunction(callee, namespaceName) {
+        var _a, _b;
+        //if we have a variable and a namespace
+        if ((0, reflection_1.isVariableExpression)(callee)) {
+            if (namespaceName) {
+                return this.calleeIsKnownNamespaceFunction(callee, namespaceName);
+            }
+            let scopes = this.program.getScopesForFile(this);
+            let lowerCalleeName = (_b = (_a = callee === null || callee === void 0 ? void 0 : callee.name) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+            for (let scope of scopes) {
+                if (scope.getCallableByName(lowerCalleeName)) {
+                    return true;
+                }
+                if (scope.getClass(lowerCalleeName)) {
+                    return true;
                 }
             }
         }
         return false;
     }
+    /**
+     * Get the token closest to the position. if no token is found, the previous token is returned
+     */
+    getClosestToken(position) {
+        let tokens = this.parser.tokens;
+        for (let i = 0; i < tokens.length; i++) {
+            let token = tokens[i];
+            if (util_1.util.rangeContains(token.range, position)) {
+                return token;
+            }
+            //if the position less than this token range, then this position touches no token,
+            if (util_1.util.positionIsGreaterThanRange(position, token.range) === false) {
+                let t = tokens[i - 1];
+                //return the token or the first token
+                return t ? t : tokens[0];
+            }
+        }
+        //return the last token
+        return tokens[tokens.length - 1];
+    }
     /**
      * Builds a list of document symbols for this file. Used by LanguageServer's onDocumentSymbol functionality
      */
@@ -1186,16 +839,16 @@ class BrsFile {
         let symbolKind;
         const children = [];
         if ((0, reflection_1.isFunctionStatement)(statement)) {
-            symbolKind = vscode_languageserver_1.SymbolKind.Function;
+            symbolKind = vscode_languageserver_2.SymbolKind.Function;
         }
         else if ((0, reflection_1.isMethodStatement)(statement)) {
-            symbolKind = vscode_languageserver_1.SymbolKind.Method;
+            symbolKind = vscode_languageserver_2.SymbolKind.Method;
         }
         else if ((0, reflection_1.isFieldStatement)(statement)) {
-            symbolKind = vscode_languageserver_1.SymbolKind.Field;
+            symbolKind = vscode_languageserver_2.SymbolKind.Field;
         }
         else if ((0, reflection_1.isNamespaceStatement)(statement)) {
-            symbolKind = vscode_languageserver_1.SymbolKind.Namespace;
+            symbolKind = vscode_languageserver_2.SymbolKind.Namespace;
             for (const childStatement of statement.body.statements) {
                 const symbol = this.getDocumentSymbol(childStatement);
                 if (symbol) {
@@ -1204,7 +857,7 @@ class BrsFile {
             }
         }
         else if ((0, reflection_1.isClassStatement)(statement)) {
-            symbolKind = vscode_languageserver_1.SymbolKind.Class;
+            symbolKind = vscode_languageserver_2.SymbolKind.Class;
             for (const childStatement of statement.body) {
                 const symbol = this.getDocumentSymbol(childStatement);
                 if (symbol) {
@@ -1216,7 +869,7 @@ class BrsFile {
             return;
         }
         const name = (0, reflection_1.isFieldStatement)(statement) ? statement.name.text : statement.getName(Parser_1.ParseMode.BrighterScript);
-        return vscode_languageserver_1.DocumentSymbol.create(name, '', symbolKind, statement.range, statement.range, children);
+        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
@@ -1225,13 +878,13 @@ class BrsFile {
         let symbolKind;
         const symbols = [];
         if ((0, reflection_1.isFunctionStatement)(statement)) {
-            symbolKind = vscode_languageserver_1.SymbolKind.Function;
+            symbolKind = vscode_languageserver_2.SymbolKind.Function;
         }
         else if ((0, reflection_1.isMethodStatement)(statement)) {
-            symbolKind = vscode_languageserver_1.SymbolKind.Method;
+            symbolKind = vscode_languageserver_2.SymbolKind.Method;
         }
         else if ((0, reflection_1.isNamespaceStatement)(statement)) {
-            symbolKind = vscode_languageserver_1.SymbolKind.Namespace;
+            symbolKind = vscode_languageserver_2.SymbolKind.Namespace;
             for (const childStatement of statement.body.statements) {
                 for (const symbol of this.generateWorkspaceSymbols(childStatement, statement)) {
                     symbols.push(symbol);
@@ -1239,7 +892,7 @@ class BrsFile {
             }
         }
         else if ((0, reflection_1.isClassStatement)(statement)) {
-            symbolKind = vscode_languageserver_1.SymbolKind.Class;
+            symbolKind = vscode_languageserver_2.SymbolKind.Class;
             for (const childStatement of statement.body) {
                 for (const symbol of this.generateWorkspaceSymbols(childStatement, statement)) {
                     symbols.push(symbol);
@@ -1251,7 +904,7 @@ class BrsFile {
         }
         const name = statement.getName(Parser_1.ParseMode.BrighterScript);
         const uri = util_1.util.pathToUri(this.srcPath);
-        const symbol = vscode_languageserver_1.SymbolInformation.create(name, symbolKind, statement.range, uri, containerStatement === null || containerStatement === void 0 ? void 0 : containerStatement.getName(Parser_1.ParseMode.BrighterScript));
+        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;
     }
@@ -1260,9 +913,10 @@ class BrsFile {
      * go to the definition of that identifier (where this thing was first defined)
      */
     getDefinition(position) {
+        var _a, _b;
         let results = [];
         //get the token at the position
-        const token = this.parser.getTokenAt(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,
@@ -1272,26 +926,62 @@ class BrsFile {
         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.parser.getTokenAt({ line: token.range.start.line, character: token.range.start.character });
+        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 this.program.getScopes()) {
+            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(vscode_languageserver_1.Location.create(util_1.util.pathToUri(callable.callable.file.srcPath), callable.callable.functionStatement.range));
+                    results.push(util_1.util.createLocation(util_1.util.pathToUri(callable.callable.file.srcPath), callable.callable.functionStatement.range));
                 }
             }
             return results;
         }
-        let classToken = this.parser.getTokenBefore(token, TokenKind_1.TokenKind.Class);
+        let classToken = this.getTokenBefore(token, TokenKind_1.TokenKind.Class);
         if (classToken) {
-            let cs = this.parser.references.classStatements.find((cs) => cs.classKeyword.range === classToken.range);
+            let cs = this._cachedLookups.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(vscode_languageserver_1.Location.create(util_1.util.pathToUri(extendedClass.file.srcPath), extendedClass.item.range));
+                    results.push(util_1.util.createLocation(util_1.util.pathToUri(extendedClass.file.srcPath), extendedClass.item.range));
                 }
             }
             return results;
@@ -1305,52 +995,51 @@ class BrsFile {
             }
             textToSearchFor = textToSearchFor.substring(startIndex, endIndex);
         }
-        const func = this.getFunctionExpressionAtPosition(position);
-        if (func) {
-            //look through local variables first
-            //find any variable with this name
-            for (const symbol of func.symbolTable.getOwnSymbols()) {
-                //we found a variable declaration with this token text
-                if (symbol.name.toLowerCase() === textToSearchFor) {
+        //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(vscode_languageserver_1.Location.create(uri, symbol.range));
+                    results.push(util_1.util.createLocation(uri, varDeclaration.nameRange));
                 }
             }
-            if (this.parser.tokenFollows(token, TokenKind_1.TokenKind.Goto)) {
-                for (const label of func.labelStatements) {
-                    if (label.tokens.identifier.text.toLocaleLowerCase() === textToSearchFor) {
+            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(vscode_languageserver_1.Location.create(uri, label.tokens.identifier.range));
+                        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 this.program.getScopesForFile(this)) {
+        for (const scope of scopesForFile) {
             for (const file of scope.getAllFiles()) {
-                if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
-                    continue;
-                }
-                filesSearched.add(file);
-                if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind) === TokenKind_1.TokenKind.Dot && file.parseMode === Parser_1.ParseMode.BrighterScript) {
-                    results.push(...this.getClassMemberDefinitions(textToSearchFor, file));
-                    const namespaceDefinition = this.getNamespaceDefinitions(token, file);
-                    if (namespaceDefinition) {
-                        results.push(namespaceDefinition);
+                if ((0, reflection_1.isBrsFile)(file) && !filesSearched.has(file)) {
+                    filesSearched.add(file);
+                    if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind) === TokenKind_1.TokenKind.Dot && file.parseMode === Parser_1.ParseMode.BrighterScript) {
+                        results.push(...this.getClassMemberDefinitions(textToSearchFor, file));
+                        const namespaceDefinition = this.getNamespaceDefinitions(token, file);
+                        if (namespaceDefinition) {
+                            results.push(namespaceDefinition);
+                        }
                     }
+                    const statementHandler = (statement) => {
+                        if (statement.getName(this.parseMode).toLowerCase() === textToSearchFor) {
+                            const uri = util_1.util.pathToUri(file.srcPath);
+                            results.push(util_1.util.createLocation(uri, statement.range));
+                        }
+                    };
+                    file.parser.ast.walk((0, visitors_1.createVisitor)({
+                        FunctionStatement: statementHandler
+                    }), {
+                        walkMode: visitors_1.WalkMode.visitStatements
+                    });
                 }
-                const statementHandler = (statement) => {
-                    if (statement.getName(this.parseMode).toLowerCase() === textToSearchFor) {
-                        const uri = util_1.util.pathToUri(file.srcPath);
-                        results.push(vscode_languageserver_1.Location.create(uri, statement.range));
-                    }
-                };
-                file.parser.ast.walk((0, visitors_1.createVisitor)({
-                    FunctionStatement: statementHandler
-                }), {
-                    walkMode: visitors_1.WalkMode.visitStatements
-                });
             }
         }
         return results;
@@ -1358,225 +1047,27 @@ class BrsFile {
     getClassMemberDefinitions(textToSearchFor, file) {
         let results = [];
         //get class fields and members
-        file.parser.ast.walk((0, visitors_1.createVisitor)({
-            MethodStatement: (statement) => {
-                if (statement.getName(file.parseMode).toLowerCase() === textToSearchFor) {
-                    results.push(vscode_languageserver_1.Location.create(util_1.util.pathToUri(file.srcPath), statement.range));
-                }
-            },
-            FieldStatement: (statement) => {
-                if (statement.name.text.toLowerCase() === textToSearchFor) {
-                    results.push(vscode_languageserver_1.Location.create(util_1.util.pathToUri(file.srcPath), statement.range));
-                }
+        const statementHandler = (statement) => {
+            if (statement.getName(file.parseMode).toLowerCase() === textToSearchFor) {
+                results.push(util_1.util.createLocation(util_1.util.pathToUri(file.srcPath), statement.range));
+            }
+        };
+        const fieldStatementHandler = (statement) => {
+            if (statement.name.text.toLowerCase() === textToSearchFor) {
+                results.push(util_1.util.createLocation(util_1.util.pathToUri(file.srcPath), statement.range));
             }
+        };
+        file.parser.ast.walk((0, visitors_1.createVisitor)({
+            MethodStatement: statementHandler,
+            FieldStatement: fieldStatementHandler
         }), {
             walkMode: visitors_1.WalkMode.visitStatements
         });
         return results;
     }
-    getHover(position) {
-        var _a, _b, _c;
-        const fence = (code) => util_1.util.mdFence(code, 'brightscript');
-        //get the token at the position
-        let token = this.parser.getTokenAt(position);
-        let hoverTokenTypes = [
-            TokenKind_1.TokenKind.Identifier,
-            TokenKind_1.TokenKind.Function,
-            TokenKind_1.TokenKind.EndFunction,
-            TokenKind_1.TokenKind.Sub,
-            TokenKind_1.TokenKind.EndSub
-        ];
-        //throw out invalid tokens and the wrong kind of tokens
-        if (!token || !hoverTokenTypes.includes(token.kind)) {
-            return null;
-        }
-        let lowerTokenText = token.text.toLowerCase();
-        //look through local variables first
-        {
-            const func = this.getFunctionExpressionAtPosition(position);
-            if (func) {
-                // this identifier could possibly be a class field, so no function expression is available
-                for (const labelStatement of (_a = func === null || func === void 0 ? void 0 : func.labelStatements) !== null && _a !== void 0 ? _a : []) {
-                    if (labelStatement.tokens.identifier.text.toLocaleLowerCase() === lowerTokenText) {
-                        return {
-                            range: token.range,
-                            contents: `${labelStatement.tokens.identifier.text}: label`
-                        };
-                    }
-                }
-            }
-            const typeTexts = new Set();
-            const fileScopes = this.program.getScopesForFile(this).sort((a, b) => { var _a; return (_a = a.dependencyGraphKey) === null || _a === void 0 ? void 0 : _a.localeCompare(b.dependencyGraphKey); });
-            const callables = [];
-            for (const scope of fileScopes) {
-                scope.linkSymbolTable();
-                const typeContext = { file: this, scope: scope, position: position };
-                const typeTextPair = this.getSymbolTypeFromToken(token, func, scope);
-                if (typeTextPair) {
-                    let scopeTypeText = '';
-                    if ((0, reflection_1.isTypedFunctionType)(typeTextPair.type)) {
-                        scopeTypeText = (_b = typeTextPair.type) === null || _b === void 0 ? void 0 : _b.toString(typeContext);
-                        //keep unique references to the callables for this function
-                        if (!typeTexts.has(scopeTypeText)) {
-                            callables.push(scope.getCallableByName(lowerTokenText));
-                        }
-                    }
-                    else if (typeTextPair.useExpandedTextOnly) {
-                        scopeTypeText = typeTextPair.expandedTokenText;
-                    }
-                    else {
-                        scopeTypeText = `${typeTextPair.expandedTokenText} as ${(_c = typeTextPair.type) === null || _c === void 0 ? void 0 : _c.toString(typeContext)}`;
-                    }
-                    if (scopeTypeText) {
-                        typeTexts.add(scopeTypeText);
-                    }
-                }
-                scope.unlinkSymbolTable();
-            }
-            if (callables.length === typeTexts.size) {
-                //this is a function in all scopes, so build the function hover
-                return {
-                    range: token.range,
-                    contents: this.getCallableDocumentation([...typeTexts], callables)
-                };
-            }
-            else if ((typeTexts === null || typeTexts === void 0 ? void 0 : typeTexts.size) > 0) {
-                const typeText = [...typeTexts].join(' | ');
-                return {
-                    range: token.range,
-                    contents: fence(typeText)
-                };
-            }
-        }
-        // //look through all callables in relevant scopes
-        // {
-        //     let scopes = this.program.getScopesForFile(this);
-        //     for (let scope of scopes) {
-        //         let callable = scope.getCallableByName(lowerTokenText);
-        //         if (callable) {
-        //             return {
-        //                 range: token.range,
-        //                 contents: this.getCallableDocumentation(callables)
-        //             };
-        //         }
-        //     }
-        // }
-    }
-    /**
-     * Build a hover documentation for a callable.
-     */
-    getCallableDocumentation(typeTexts, callables) {
-        var _a;
-        const callable = callables[0];
-        const typeText = typeTexts[0];
-        const comments = [];
-        const tokens = callable === null || callable === void 0 ? void 0 : callable.file.parser.tokens;
-        const idx = tokens === null || tokens === void 0 ? void 0 : tokens.indexOf((_a = callable.functionStatement) === null || _a === void 0 ? void 0 : _a.func.functionType);
-        for (let i = idx - 1; i >= 0; i--) {
-            const token = tokens[i];
-            //skip whitespace and newline chars
-            if (token.kind === TokenKind_1.TokenKind.Comment) {
-                comments.push(token);
-            }
-            else if (token.kind === TokenKind_1.TokenKind.Newline || token.kind === TokenKind_1.TokenKind.Whitespace) {
-                //skip these tokens
-                continue;
-                //any other token means there are no more comments
-            }
-            else {
-                break;
-            }
-        }
-        //message indicating if there are variations. example: (+3 variations) if there are 4 unique function signatures
-        const multiText = callables.length > 1 ? ` (+${callables.length - 1} variations)` : '';
-        let result = util_1.util.mdFence(typeText + multiText, 'brightscript');
-        if (comments.length > 0) {
-            result += '\n***\n' + comments.reverse().map(x => x.text.replace(/^('|rem)/i, '')).join('\n');
-        }
-        return result;
-    }
-    getSignatureHelpForNamespaceMethods(callableName, dottedGetText, scope) {
-        var _a;
-        if (!dottedGetText) {
-            return [];
-        }
-        let resultsMap = new Map();
-        for (let [, namespace] of scope.namespaceLookup) {
-            //completionName = "NameA."
-            //completionName = "NameA.Na
-            //NameA
-            //NameA.NameB
-            //NameA.NameB.NameC
-            if (namespace.fullName.toLowerCase() === dottedGetText.toLowerCase()) {
-                //add function and class statement completions
-                for (let stmt of namespace.statements) {
-                    if ((0, reflection_1.isFunctionStatement)(stmt) && stmt.name.text.toLowerCase() === callableName.toLowerCase()) {
-                        const result = (_a = namespace.file) === null || _a === void 0 ? void 0 : _a.getSignatureHelpForStatement(stmt);
-                        if (!resultsMap.has(result.key)) {
-                            resultsMap.set(result.key, result);
-                        }
-                    }
-                }
-            }
-        }
-        return [...resultsMap.values()];
-    }
-    getSignatureHelpForStatement(statement) {
-        if (!(0, reflection_1.isFunctionStatement)(statement) && !(0, reflection_1.isMethodStatement)(statement)) {
-            return undefined;
-        }
-        const func = statement.func;
-        const funcStartPosition = func.range.start;
-        // Get function comments in reverse order
-        let currentToken = this.parser.getTokenAt(funcStartPosition);
-        let functionComments = [];
-        while (currentToken) {
-            currentToken = this.parser.getPreviousToken(currentToken);
-            if (!currentToken) {
-                break;
-            }
-            if (currentToken.range.start.line + 1 < funcStartPosition.line) {
-                if (functionComments.length === 0) {
-                    break;
-                }
-            }
-            const kind = currentToken.kind;
-            if (kind === TokenKind_1.TokenKind.Comment) {
-                // Strip off common leading characters to make it easier to read
-                const commentText = currentToken.text.replace(/^[' *\/]+/, '');
-                functionComments.unshift(commentText);
-            }
-            else if (kind === TokenKind_1.TokenKind.Newline) {
-                if (functionComments.length === 0) {
-                    continue;
-                }
-                // if we already had a new line as the last token then exit out
-                if (functionComments[0] === currentToken.text) {
-                    break;
-                }
-                functionComments.unshift(currentToken.text);
-            }
-            else {
-                break;
-            }
-        }
-        const documentation = functionComments.join('').trim();
-        const lines = util_1.util.splitIntoLines(this.fileContents);
-        let key = statement.name.text + documentation;
-        const params = [];
-        for (const param of func.parameters) {
-            params.push(vscode_languageserver_1.ParameterInformation.create(param.name.text));
-            key += param.name.text;
-        }
-        const label = util_1.util.getTextForRange(lines, func.functionDeclarationRange).trim();
-        const signature = vscode_languageserver_1.SignatureInformation.create(label, documentation, ...params);
-        const index = 1;
-        return { key: key, signature: signature, index: index };
-    }
     getClassMethod(classStatement, name, walkParents = true) {
         var _a;
-        //TODO - would like to write this with getClassHierarchy; but got stuck on working out the scopes to use... :(
-        //TODO types - this could be solved with symbolTable?
+        //TODO - would like to write this with getClassHieararchy; but got stuck on working out the scopes to use... :(
         let statement;
         const statementHandler = (e) => {
             if (!statement && e.name.text.toLowerCase() === name.toLowerCase()) {
@@ -1602,45 +1093,55 @@ class BrsFile {
         }
         return statement;
     }
-    getClassSignatureHelp(classStatement) {
-        const classConstructor = this.getClassMethod(classStatement, 'new');
-        let sigHelp = classConstructor ? this.getSignatureHelpForStatement(classConstructor) : undefined;
-        if (sigHelp) {
-            sigHelp.key = classStatement.getName(Parser_1.ParseMode.BrighterScript);
-            sigHelp.signature.label = sigHelp.signature.label.replace(/(function|sub) new/, sigHelp.key);
-        }
-        return sigHelp;
-    }
     getReferences(position) {
-        const callSiteToken = this.parser.getTokenAt(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.isXmlFile)(file) || processedFiles.has(file)) {
-                    continue;
-                }
-                processedFiles.add(file);
-                file.ast.walk((0, visitors_1.createVisitor)({
-                    VariableExpression: (e) => {
-                        if (e.name.text.toLowerCase() === searchFor) {
-                            locations.push(vscode_languageserver_1.Location.create(util_1.util.pathToUri(file.srcPath), e.range));
+                if ((0, reflection_1.isBrsFile)(file) && !processedFiles.has(file)) {
+                    processedFiles.add(file);
+                    file.ast.walk((0, visitors_1.createVisitor)({
+                        VariableExpression: (e) => {
+                            if (e.name.text.toLowerCase() === searchFor) {
+                                locations.push(util_1.util.createLocation(util_1.util.pathToUri(file.srcPath), e.range));
+                            }
                         }
-                    }
-                }), {
-                    walkMode: visitors_1.WalkMode.visitExpressionsRecursive
-                });
+                    }), {
+                        walkMode: visitors_1.WalkMode.visitExpressionsRecursive
+                    });
+                }
             }
         }
         return locations;
     }
+    /**
+     * Generate the code, map, and typedef for this file
+     */
+    serialize() {
+        const result = {};
+        const transpiled = this.transpile();
+        if (typeof transpiled.code === 'string') {
+            result.code = transpiled.code;
+        }
+        if (transpiled.map) {
+            result.map = transpiled.map.toString();
+        }
+        //generate the typedef (if this is not a typedef itself, and if enabled)
+        if (!this.isTypedef && this.program.options.emitDefinitions) {
+            result.typedef = this.getTypedef();
+        }
+        return result;
+    }
     /**
      * Convert the brightscript/brighterscript source code into valid brightscript
      */
     transpile() {
+        var _a;
         const state = new BrsTranspileState_1.BrsTranspileState(this);
+        state.editor = (_a = this.editor) !== null && _a !== void 0 ? _a : new Editor_1.Editor();
         let transpileResult;
         if (this.needsTranspiled) {
             transpileResult = new source_map_1.SourceNode(null, null, state.srcPath, this.ast.transpile(state));
@@ -1653,8 +1154,11 @@ class BrsFile {
             //simple SourceNode wrapping the entire file to simplify the logic below
             transpileResult = new source_map_1.SourceNode(null, null, state.srcPath, this.fileContents);
         }
-        //undo any AST edits that the transpile cycle has made
-        state.editor.undoAll();
+        //if we created an editor for this flow, undo the edits now
+        if (!this.editor) {
+            //undo any AST edits that the transpile cycle has made
+            state.editor.undoAll();
+        }
         if (this.program.options.sourceMap) {
             return new source_map_1.SourceNode(null, null, null, [
                 transpileResult,
@@ -1669,6 +1173,206 @@ 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, _b, _c;
+            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();
+                    for (const flag of [SymbolTable_1.SymbolTypeFlag.runtime, SymbolTable_1.SymbolTypeFlag.typetime]) {
+                        // eslint-disable-next-line no-bitwise
+                        if (symbol.flags & flag) {
+                            if ((_a = this.providedSymbols.symbolMap.get(flag)) === null || _a === void 0 ? void 0 : _a.has(fullSymbolKey)) {
+                                // this catches namespaced things
+                                continue;
+                            }
+                            if (!((_b = addedSymbols.get(flag)) === null || _b === void 0 ? void 0 : _b.has(fullSymbolKey))) {
+                                requiredSymbols.push(symbol);
+                                (_c = addedSymbols.get(flag)) === null || _c === void 0 ? void 0 : _c.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._cachedLookups.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._cachedLookups.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);
@@ -1676,30 +1380,14 @@ class BrsFile {
         return programNode.toString();
     }
     dispose() {
-        var _a, _b;
+        var _a;
         (_a = this._parser) === null || _a === void 0 ? void 0 : _a.dispose();
-        //unsubscribe from any DependencyGraph subscriptions
-        (_b = this.unsubscribeFromDependencyGraph) === null || _b === void 0 ? void 0 : _b.call(this);
         //deleting these properties result in lower memory usage (garbage collection is magic!)
         delete this.fileContents;
         delete this._parser;
-        delete this.callables;
-        delete this.functionCalls;
+        delete this._functionScopes;
+        delete this.scopesByFunc;
     }
 }
 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_1.CompletionItemKind.Keyword
-    };
-});
 //# sourceMappingURL=BrsFile.js.map