brighterscript 0.41.2 → 1.0.0-alpha.12

package/dist/parser/Parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.References = exports.ParseMode = exports.Parser = void 0;
+exports.getBscTypeFromExpression = exports.TokenUsage = exports.References = exports.ParseMode = exports.Parser = void 0;
 const lexer_1 = require("../lexer");
 const Statement_1 = require("./Statement");
 const DiagnosticMessages_1 = require("../DiagnosticMessages");
@@ -10,6 +10,11 @@ const Logger_1 = require("../Logger");
 const reflection_1 = require("../astUtils/reflection");
 const visitors_1 = require("../astUtils/visitors");
 const creators_1 = require("../astUtils/creators");
+const DynamicType_1 = require("../types/DynamicType");
+const SymbolTable_1 = require("../SymbolTable");
+const ObjectType_1 = require("../types/ObjectType");
+const ArrayType_1 = require("../types/ArrayType");
+const helpers_1 = require("../types/helpers");
 const _1 = require(".");
 class Parser {
     constructor() {
@@ -21,6 +26,7 @@ class Parser {
          * The list of statements for the parsed file
          */
         this.ast = new Statement_1.Body([]);
+        this.symbolTable = new SymbolTable_1.SymbolTable();
         this._references = new References();
         this.globalTerminators = [];
         /**
@@ -31,6 +37,10 @@ class Parser {
     get statements() {
         return this.ast.statements;
     }
+    get currentSymbolTable() {
+        var _a, _b;
+        return (_b = (_a = this.currentFunctionExpression) === null || _a === void 0 ? void 0 : _a.symbolTable) !== null && _b !== void 0 ? _b : this.symbolTable;
+    }
     /**
      * References for significant statements/expressions in the parser.
      * These are initially extracted during parse-time to improve performance, but will also be dynamically regenerated if need be.
@@ -66,6 +76,10 @@ class Parser {
             }
         }
     }
+    get currentNamespaceName() {
+        var _a;
+        return (_a = this.currentNamespace) === null || _a === void 0 ? void 0 : _a.nameExpression;
+    }
     /**
      * Get the currently active global terminators
      */
@@ -242,7 +256,7 @@ class Parser {
         this.warnIfNotBrighterScriptMode('interface declarations');
         const parentAnnotations = this.enterAnnotationBlock();
         const interfaceToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(lexer_1.TokenKind.Interface), lexer_1.TokenKind.Interface);
-        const nameToken = this.identifier();
+        const nameToken = this.identifier(...this.allowedLocalIdentifiers);
         let extendsToken;
         let parentInterfaceName;
         if (this.peek().text.toLowerCase() === 'extends') {
@@ -336,7 +350,7 @@ class Parser {
                 }
                 //methods (function/sub keyword OR identifier followed by opening paren)
                 if (this.checkAny(lexer_1.TokenKind.Function, lexer_1.TokenKind.Sub) || (this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties) && this.checkNext(lexer_1.TokenKind.LeftParen))) {
-                    const funcDeclaration = this.functionDeclaration(false, false);
+                    const funcDeclaration = this.functionDeclaration(false, false, true);
                     //remove this function from the lists because it's not a callable
                     const functionStatement = this._references.functionStatements.pop();
                     //if we have an overrides keyword AND this method is called 'new', that's not allowed
@@ -375,7 +389,10 @@ class Parser {
         if (endingKeyword.kind !== lexer_1.TokenKind.EndClass) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('class')), { range: endingKeyword.range }));
         }
-        const result = new Statement_1.ClassStatement(classKeyword, className, body, endingKeyword, extendsKeyword, parentClassName, this.currentNamespaceName);
+        const result = new Statement_1.ClassStatement(classKeyword, className, body, endingKeyword, extendsKeyword, parentClassName, this.currentNamespaceName, this.currentSymbolTable);
+        if (className) {
+            this.currentSymbolTable.addSymbol(className.text, className.range, result.getConstructorFunctionType());
+        }
         this._references.classStatements.push(result);
         this.exitAnnotationBlock(parentAnnotations);
         return result;
@@ -389,7 +406,7 @@ class Parser {
             asToken = this.advance();
             fieldType = this.typeToken();
             //no field type specified
-            if (!util_1.util.tokenToBscType(fieldType)) {
+            if (!util_1.util.tokenToBscType(fieldType, true, this.currentNamespaceName)) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedValidTypeToFollowAsKeyword()), { range: this.peek().range }));
             }
         }
@@ -400,10 +417,10 @@ class Parser {
             equal = this.advance();
             initialValue = this.expression();
         }
-        return new Statement_1.ClassFieldStatement(accessModifier, name, asToken, fieldType, equal, initialValue);
+        return new Statement_1.ClassFieldStatement(accessModifier, name, asToken, fieldType, equal, initialValue, this.currentNamespaceName);
     }
-    functionDeclaration(isAnonymous, checkIdentifier = true) {
-        var _a;
+    functionDeclaration(isAnonymous, checkIdentifier = true, forClassMethod = false) {
+        var _a, _b, _c, _d;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
         try {
@@ -463,7 +480,7 @@ class Parser {
             if (this.check(lexer_1.TokenKind.As)) {
                 asToken = this.advance();
                 typeToken = this.typeToken();
-                if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript)) {
+                if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript, this.currentNamespaceName)) {
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType((_a = typeToken.text) !== null && _a !== void 0 ? _a : '')), { range: typeToken.range }));
                 }
             }
@@ -476,11 +493,25 @@ class Parser {
             this.consumeStatementSeparators(true);
             let func = new Expression_1.FunctionExpression(params, undefined, //body
             functionType, undefined, //ending keyword
-            leftParen, rightParen, asToken, typeToken, this.currentFunctionExpression, this.currentNamespaceName);
+            leftParen, rightParen, asToken, typeToken, //return type
+            this.currentFunctionExpression, this.currentNamespaceName, (_c = (_b = this.currentNamespace) === null || _b === void 0 ? void 0 : _b.symbolTable) !== null && _c !== void 0 ? _c : this.symbolTable);
             //if there is a parent function, register this function with the parent
             if (this.currentFunctionExpression) {
                 this.currentFunctionExpression.childFunctionExpressions.push(func);
             }
+            // add the function to the relevant symbol tables
+            if (!isAnonymous && !forClassMethod) {
+                const funcType = func.getFunctionType();
+                funcType.setName(name.text);
+                // add the function as declared to the current namespace's table
+                (_d = this.currentNamespace) === null || _d === void 0 ? void 0 : _d.symbolTable.addSymbol(name.text, name.range, funcType);
+                let fullyQualifiedName = name.text;
+                if (this.currentNamespaceName) {
+                    // add the "namespaced" name of this function to the parent symbol table
+                    fullyQualifiedName = this.currentNamespaceName.getName(ParseMode.BrighterScript) + '.' + name.text;
+                }
+                this.currentSymbolTable.addSymbol(fullyQualifiedName, name.range, funcType);
+            }
             this._references.functionExpressions.push(func);
             let previousFunctionExpression = this.currentFunctionExpression;
             this.currentFunctionExpression = func;
@@ -526,13 +557,13 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedParameterNameButFound(this.peek().text)), { range: this.peek().range }));
             throw this.lastDiagnosticAsError();
         }
-        let name = this.advance();
-        // force the name into an identifier so the AST makes some sense
-        name.kind = lexer_1.TokenKind.Identifier;
+        const name = this.identifier(...lexer_1.AllowedLocalIdentifiers);
         let typeToken;
         let defaultValue;
+        let equalsToken;
         // parse argument default value
         if (this.match(lexer_1.TokenKind.Equal)) {
+            equalsToken = this.previous();
             // it seems any expression is allowed here -- including ones that operate on other arguments!
             defaultValue = this.expression();
         }
@@ -540,15 +571,28 @@ class Parser {
         if (this.check(lexer_1.TokenKind.As)) {
             asToken = this.advance();
             typeToken = this.typeToken();
-            if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript)) {
+            if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript, this.currentNamespaceName)) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
                 throw this.lastDiagnosticAsError();
             }
         }
-        return new Expression_1.FunctionParameterExpression(name, typeToken, defaultValue, asToken, this.currentNamespaceName);
+        let type;
+        if (typeToken) {
+            type = util_1.util.tokenToBscType(typeToken, true, this.currentNamespaceName);
+        }
+        else if (defaultValue) {
+            type = getBscTypeFromExpression(defaultValue, this.currentFunctionExpression);
+            if ((0, reflection_1.isInvalidType)(type)) {
+                type = new DynamicType_1.DynamicType();
+            }
+        }
+        else {
+            type = new DynamicType_1.DynamicType();
+        }
+        return new Expression_1.FunctionParameterExpression(name, type, equalsToken, defaultValue, asToken, typeToken, this.currentNamespaceName);
     }
     assignment() {
-        let name = this.advance();
+        let name = this.identifier(...this.allowedLocalIdentifiers);
         //add diagnostic if name is a reserved word that cannot be used as an identifier
         if (lexer_1.DisallowedLocalIdentifiersText.has(name.text.toLowerCase())) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(name.text)), { range: name.range }));
@@ -557,12 +601,14 @@ class Parser {
         let value = this.expression();
         let result;
         if (operator.kind === lexer_1.TokenKind.Equal) {
-            result = new Statement_1.AssignmentStatement(operator, name, value, this.currentFunctionExpression);
+            result = new Statement_1.AssignmentStatement(name, operator, value, this.currentFunctionExpression);
         }
         else {
-            result = new Statement_1.AssignmentStatement(operator, name, new Expression_1.BinaryExpression(new Expression_1.VariableExpression(name, this.currentNamespaceName), operator, value), this.currentFunctionExpression);
+            result = new Statement_1.AssignmentStatement(name, operator, new Expression_1.BinaryExpression(new Expression_1.VariableExpression(name, this.currentNamespaceName), operator, value), this.currentFunctionExpression);
         }
         this._references.assignmentStatements.push(result);
+        const assignmentType = getBscTypeFromExpression(result.value, this.currentFunctionExpression);
+        this.currentSymbolTable.addSymbol(name.text, name.range, assignmentType);
         return result;
     }
     checkLibrary() {
@@ -717,7 +763,7 @@ class Parser {
     }
     forEachStatement() {
         let forEach = this.advance();
-        let name = this.advance();
+        let name = this.identifier(...this.allowedLocalIdentifiers);
         let maybeIn = this.peek();
         if (this.check(lexer_1.TokenKind.Identifier) && maybeIn.text.toLowerCase() === 'in') {
             this.advance();
@@ -738,11 +784,10 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         let endFor = this.advance();
-        return new Statement_1.ForEachStatement({
-            forEach: forEach,
-            in: maybeIn,
-            endFor: endFor
-        }, name, target, body);
+        //TODO TYPES infer type from `target`
+        const itemType = new DynamicType_1.DynamicType();
+        this.currentSymbolTable.addSymbol(name.text, name.range, itemType);
+        return new Statement_1.ForEachStatement(forEach, name, maybeIn, target, body, endFor);
     }
     exitFor() {
         let keyword = this.advance();
@@ -773,12 +818,13 @@ class Parser {
         this.namespaceAndFunctionDepth++;
         let name = this.getNamespacedVariableNameExpression();
         //set the current namespace name
-        this.currentNamespaceName = name;
+        let result = new Statement_1.NamespaceStatement(keyword, name, null, null, this.currentSymbolTable);
+        this.currentNamespace = result;
         this.globalTerminators.push([lexer_1.TokenKind.EndNamespace]);
         let body = this.body();
         this.globalTerminators.pop();
         //unset the current namespace name
-        this.currentNamespaceName = undefined;
+        this.currentNamespace = undefined;
         let endKeyword;
         if (this.check(lexer_1.TokenKind.EndNamespace)) {
             endKeyword = this.advance();
@@ -788,7 +834,8 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('namespace')), { range: keyword.range }));
         }
         this.namespaceAndFunctionDepth--;
-        let result = new Statement_1.NamespaceStatement(keyword, name, body, endKeyword);
+        result.body = body;
+        result.endKeyword = endKeyword;
         this._references.namespaceStatements.push(result);
         return result;
     }
@@ -1276,9 +1323,11 @@ class Parser {
                     : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare);
             }
             else if ((0, reflection_1.isDottedGetExpression)(left)) {
-                return new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === lexer_1.TokenKind.Equal
+                const dottedSetStmt = new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === lexer_1.TokenKind.Equal
                     ? right
                     : new Expression_1.BinaryExpression(left, operator, right));
+                this._references.dottedSetStatements.push(dottedSetStmt);
+                return dottedSetStmt;
             }
         }
         return this.expressionStatement(expr);
@@ -1338,7 +1387,9 @@ class Parser {
             this.current -= 2;
             throw new CancelStatementError();
         }
-        return new Statement_1.LabelStatement(tokens);
+        const stmt = new Statement_1.LabelStatement(tokens);
+        this.currentFunctionExpression.labelStatements.push(stmt);
+        return stmt;
     }
     /**
      * Parses a `goto` statement
@@ -1735,7 +1786,7 @@ class Parser {
                     else {
                         let k = key();
                         let expr = this.expression();
-                        lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr);
+                        lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr, getBscTypeFromExpression(expr, this.currentFunctionExpression));
                         members.push(lastAAMember);
                     }
                     while (this.matchAny(lexer_1.TokenKind.Comma, lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Comment)) {
@@ -1762,14 +1813,15 @@ class Parser {
                             }
                             let k = key();
                             let expr = this.expression();
-                            lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr);
+                            lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr, getBscTypeFromExpression(expr, this.currentFunctionExpression));
                             members.push(lastAAMember);
                         }
                     }
                     this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), lexer_1.TokenKind.RightCurlyBrace);
                 }
                 let closingBrace = this.previous();
-                const aaExpr = new Expression_1.AALiteralExpression(members, openingBrace, closingBrace);
+                const aaExpr = new Expression_1.AALiteralExpression(members, openingBrace, closingBrace, this.currentFunctionExpression);
+                this._references.aaLiterals.push(aaExpr);
                 this.addPropertyHints(aaExpr);
                 return aaExpr;
             case this.matchAny(lexer_1.TokenKind.Pos, lexer_1.TokenKind.Tab):
@@ -1945,6 +1997,235 @@ class Parser {
             this.advance();
         }
     }
+    /**
+     * Get the token at the specified position
+     * @param position
+     */
+    getTokenAt(position) {
+        for (let token of this.tokens) {
+            if (util_1.util.rangeContains(token.range, position)) {
+                return token;
+            }
+        }
+    }
+    /**
+     * Get the token closest to the position. if no token is found, the previous token is returned
+     * @param position
+     * @param tokens
+     */
+    getClosestToken(position) {
+        let tokens = this.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];
+    }
+    isPositionNextToTokenKind(position, tokenKind) {
+        const closestToken = this.getClosestToken(position);
+        const previousToken = this.getPreviousToken(closestToken);
+        const previousTokenKind = previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind;
+        //next to matched token
+        if (!closestToken || closestToken.kind === lexer_1.TokenKind.Eof) {
+            return false;
+        }
+        else if (closestToken.kind === tokenKind) {
+            return true;
+        }
+        else if (closestToken.kind === lexer_1.TokenKind.Newline || previousTokenKind === lexer_1.TokenKind.Newline) {
+            return false;
+            //next to an identifier, which is next to token kind
+        }
+        else if (closestToken.kind === lexer_1.TokenKind.Identifier && previousTokenKind === tokenKind) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    getTokenBefore(currentToken, tokenKind) {
+        const index = this.tokens.indexOf(currentToken);
+        for (let i = index - 1; i >= 0; i--) {
+            currentToken = this.tokens[i];
+            if (currentToken.kind === lexer_1.TokenKind.Newline) {
+                break;
+            }
+            else if (currentToken.kind === tokenKind) {
+                return currentToken;
+            }
+        }
+        return undefined;
+    }
+    tokenFollows(currentToken, tokenKind) {
+        const index = this.tokens.indexOf(currentToken);
+        if (index > 0) {
+            return this.tokens[index - 1].kind === tokenKind;
+        }
+        return false;
+    }
+    getTokensUntil(currentToken, tokenKind, direction = -1) {
+        let tokens = [];
+        for (let i = this.tokens.indexOf(currentToken); direction === -1 ? i >= 0 : i === this.tokens.length; i += direction) {
+            currentToken = this.tokens[i];
+            if (currentToken.kind === lexer_1.TokenKind.Newline || currentToken.kind === tokenKind) {
+                break;
+            }
+            tokens.push(currentToken);
+        }
+        return tokens;
+    }
+    getPreviousToken(token) {
+        let idx = this.tokens.indexOf(token);
+        return this.tokens[idx - 1];
+    }
+    getPreviousTokenFromIndex(idx) {
+        return { token: this.tokens[idx - 1], index: idx - 1 };
+    }
+    getPreviousTokenIgnoreNests(currentTokenIndex, leftBracketType, rightBracketType) {
+        let currentToken = this.tokens[currentTokenIndex];
+        let previousTokenResult;
+        function isRightBracket(token) {
+            return (token === null || token === void 0 ? void 0 : token.kind) === rightBracketType;
+        }
+        function isLeftBracket(token) {
+            return (token === null || token === void 0 ? void 0 : token.kind) === leftBracketType;
+        }
+        let lastTokenHadLeadingWhitespace = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.leadingWhitespace.length) > 0;
+        let lastTokenWasLeftBracket = false;
+        let bracketNestCount = 0;
+        let hasBrackets = false;
+        // check for nested function call
+        if (isRightBracket(currentToken)) {
+            bracketNestCount++;
+            hasBrackets = true;
+        }
+        while (currentToken && bracketNestCount > 0) {
+            previousTokenResult = this.getPreviousTokenFromIndex(currentTokenIndex);
+            currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
+            currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
+            lastTokenWasLeftBracket = false;
+            if (isRightBracket(currentToken)) {
+                bracketNestCount++;
+            }
+            while (isLeftBracket(currentToken)) {
+                bracketNestCount--;
+                lastTokenWasLeftBracket = true;
+                lastTokenHadLeadingWhitespace = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.leadingWhitespace.length) > 0;
+                previousTokenResult = this.getPreviousTokenFromIndex(currentTokenIndex);
+                currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
+                currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
+            }
+        }
+        // We will not be able to decipher the token type if it was in brackets
+        // e.g (someVar+otherVar).toStr() -- we don't bother trying to decipher what "(someVar+otherVar)" is
+        let isUnknown = (lastTokenWasLeftBracket && (lastTokenHadLeadingWhitespace || !this.isAcceptableChainToken(currentToken)));
+        const tokenWithIndex = { token: currentToken, index: currentTokenIndex, tokenTypeIsNotKnowable: isUnknown, hasBrackets: hasBrackets };
+        return tokenWithIndex;
+    }
+    /**
+     * Finds the previous token in a chain (e.g. 'm.obj.func(someFunc()).value'), skipping over any arguments of function calls
+     * If this function was called with the token at 'value' above, the previous identifier in the chain is 'func'
+     * @param currentTokenIndex token index to start from
+     * @param allowCurrent can the current token be the token that's the identifier?
+     * @returns the previous identifer
+     */
+    getPreviousTokenInChain(currentTokenIndex, allowCurrent = false) {
+        let currentToken = this.tokens[currentTokenIndex];
+        let previousTokenResult;
+        let usage = TokenUsage.Direct;
+        if (!allowCurrent) {
+            previousTokenResult = this.getPreviousTokenFromIndex(currentTokenIndex);
+            currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
+            currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
+        }
+        if ((currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === lexer_1.TokenKind.Dot) {
+            previousTokenResult = this.getPreviousTokenFromIndex(currentTokenIndex);
+            currentToken = previousTokenResult.token;
+            currentTokenIndex = previousTokenResult.index;
+        }
+        previousTokenResult = this.getPreviousTokenIgnoreNests(currentTokenIndex, lexer_1.TokenKind.LeftParen, lexer_1.TokenKind.RightParen);
+        currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
+        currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
+        if (previousTokenResult.hasBrackets) {
+            usage = TokenUsage.Call;
+        }
+        let tokenTypeIsNotKnowable = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.tokenTypeIsNotKnowable;
+        if (currentTokenIndex) {
+            previousTokenResult = this.getPreviousTokenIgnoreNests(currentTokenIndex, lexer_1.TokenKind.LeftSquareBracket, lexer_1.TokenKind.RightSquareBracket);
+            currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
+            currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
+            if (previousTokenResult.hasBrackets) {
+                usage = TokenUsage.ArrayReference;
+            }
+        }
+        tokenTypeIsNotKnowable = tokenTypeIsNotKnowable || (previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.tokenTypeIsNotKnowable);
+        if (tokenTypeIsNotKnowable || this.isAcceptableChainToken(currentToken)) {
+            // either we have a valid chain token, or we can't know what the token type is
+            return { token: currentToken, index: currentTokenIndex, tokenTypeIsNotKnowable: tokenTypeIsNotKnowable, usage: usage };
+        }
+        return undefined;
+    }
+    isAcceptableChainToken(currentToken, lastTokenHasWhitespace = false) {
+        if (!currentToken || lastTokenHasWhitespace) {
+            return false;
+        }
+        if (currentToken.kind === lexer_1.TokenKind.Identifier) {
+            return true;
+        }
+        if (currentToken.leadingWhitespace.length === 0) {
+            // start of the chain
+            return lexer_1.AllowedLocalIdentifiers.includes(currentToken.kind);
+        }
+        // not the start of the chain
+        return lexer_1.AllowedProperties.includes(currentToken.kind);
+    }
+    /**
+     * Builds up a chain of tokens, starting with the first in the chain, and ending with currentToken
+     * e.g. m.prop.method().field (with 'field' as currentToken) -> ["m", "prop", "method", "field"], with each element as a token
+     * @param currentToken the token that is the end of the chain
+     * @returns array of tokens
+     */
+    getTokenChain(currentToken) {
+        const tokenChain = [];
+        let currentTokenIndex = this.tokens.indexOf(currentToken);
+        let previousTokenResult;
+        let lastTokenHasWhitespace = false;
+        let includesUnknown = false;
+        previousTokenResult = this.getPreviousTokenInChain(currentTokenIndex, true);
+        currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
+        currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
+        if (this.isAcceptableChainToken(currentToken)) {
+            tokenChain.push(previousTokenResult);
+            lastTokenHasWhitespace = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.leadingWhitespace.length) > 0;
+        }
+        if (!lastTokenHasWhitespace) {
+            previousTokenResult = this.getPreviousTokenInChain(currentTokenIndex);
+            currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
+            currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
+            includesUnknown = !!(previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.tokenTypeIsNotKnowable);
+            while (!includesUnknown && this.isAcceptableChainToken(currentToken, lastTokenHasWhitespace)) {
+                tokenChain.push(previousTokenResult);
+                lastTokenHasWhitespace = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.leadingWhitespace.length) > 0;
+                if (!lastTokenHasWhitespace) {
+                    previousTokenResult = this.getPreviousTokenInChain(currentTokenIndex);
+                    currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
+                    currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
+                    includesUnknown = includesUnknown || (previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.tokenTypeIsNotKnowable);
+                }
+            }
+        }
+        tokenChain.reverse();
+        return { chain: tokenChain, includesUnknowableTokenType: !!includesUnknown };
+    }
     /**
      * References are found during the initial parse.
      * However, sometimes plugins can modify the AST, requiring a full walk to re-compute all references.
@@ -1952,10 +2233,8 @@ class Parser {
      */
     findReferences() {
         this._references = new References();
+        //gather up all the top-level statements
         this.ast.walk((0, visitors_1.createVisitor)({
-            AssignmentStatement: s => {
-                this._references.assignmentStatements.push(s);
-            },
             ClassStatement: s => {
                 this._references.classStatements.push(s);
             },
@@ -1964,12 +2243,22 @@ class Parser {
             },
             FunctionStatement: s => {
                 this._references.functionStatements.push(s);
+                //add the initial set of function expressions for function statements
+                this._references.functionExpressions.push(s.func);
             },
             ImportStatement: s => {
                 this._references.importStatements.push(s);
             },
             LibraryStatement: s => {
                 this._references.libraryStatements.push(s);
+            }
+        }), {
+            walkMode: visitors_1.WalkMode.visitStatements
+        });
+        let func;
+        let visitor = (0, visitors_1.createVisitor)({
+            AssignmentStatement: s => {
+                this._references.assignmentStatements.push(s);
             },
             FunctionExpression: (expression, parent) => {
                 if (!(0, reflection_1.isClassMethodStatement)(parent)) {
@@ -1988,9 +2277,27 @@ class Parser {
             DottedSetStatement: e => {
                 this.addPropertyHints(e.name);
             }
-        }), {
-            walkMode: visitors_1.WalkMode.visitAllRecursive
         });
+        //walk all function expressions (we'll add new ones as we move along too)
+        for (let i = 0; i < this._references.functionExpressions.length; i++) {
+            func = this._references.functionExpressions[i];
+            //walk this function expression
+            func.body.walk(visitor, {
+                walkMode: visitors_1.WalkMode.visitAll
+            });
+        }
+    }
+    getContainingClass(currentToken) {
+        return this.references.classStatements.find((cs) => util_1.util.rangeContains(cs.range, currentToken.range.start));
+    }
+    getContainingAA(currentToken) {
+        return this.references.aaLiterals.find((aa) => util_1.util.rangeContains(aa.range, currentToken.range.start));
+    }
+    getContainingNamespace(currentToken) {
+        return this.references.namespaceStatements.find((cs) => util_1.util.rangeContains(cs.range, currentToken.range.start));
+    }
+    getContainingFunctionExpression(currentToken) {
+        return this.references.functionExpressions.find((fe) => util_1.util.rangeContains(fe.range, currentToken.range.start));
     }
     dispose() {
     }
@@ -2005,6 +2312,8 @@ class References {
     constructor() {
         this.assignmentStatements = [];
         this.classStatements = [];
+        this.dottedSetStatements = [];
+        this.aaLiterals = [];
         this.functionExpressions = [];
         this.functionStatements = [];
         this.interfaceStatements = [];
@@ -2046,9 +2355,61 @@ class References {
     }
 }
 exports.References = References;
+var TokenUsage;
+(function (TokenUsage) {
+    TokenUsage[TokenUsage["Direct"] = 1] = "Direct";
+    TokenUsage[TokenUsage["Call"] = 2] = "Call";
+    TokenUsage[TokenUsage["ArrayReference"] = 3] = "ArrayReference";
+})(TokenUsage = exports.TokenUsage || (exports.TokenUsage = {}));
 class CancelStatementError extends Error {
     constructor() {
         super('CancelStatement');
     }
 }
+/**
+ * Gets the type of an expression. If it can not be processed, will return DynamicType
+ *
+ * @param expression the Expression to process
+ * @param functionExpression the wrapping function expression
+ * @return the best guess type of that expression
+ */
+function getBscTypeFromExpression(expression, functionExpression) {
+    try {
+        if ((0, reflection_1.isFunctionExpression)(expression)) {
+            return expression.getFunctionType();
+            //literal
+        }
+        else if ((0, reflection_1.isLiteralExpression)(expression)) {
+            return expression.type;
+            //Associative array literal
+        }
+        else if ((0, reflection_1.isAALiteralExpression)(expression)) {
+            return new ObjectType_1.ObjectType(expression.memberTable);
+            //Array literal
+        }
+        else if ((0, reflection_1.isArrayLiteralExpression)(expression)) {
+            return new ArrayType_1.ArrayType();
+            //function call
+        }
+        else if ((0, reflection_1.isNewExpression)(expression)) {
+            return (0, helpers_1.getTypeFromNewExpression)(expression, functionExpression); // new CustomType(expression.className.getName(ParseMode.BrighterScript));
+            //Function call
+        }
+        else if ((0, reflection_1.isCallExpression)(expression)) {
+            return (0, helpers_1.getTypeFromCallExpression)(expression, functionExpression);
+        }
+        else if ((0, reflection_1.isVariableExpression)(expression)) {
+            return (0, helpers_1.getTypeFromVariableExpression)(expression, functionExpression);
+        }
+        else if ((0, reflection_1.isDottedGetExpression)(expression)) {
+            return (0, helpers_1.getTypeFromDottedGetExpression)(expression, functionExpression);
+        }
+    }
+    catch (e) {
+        //do nothing. Just return dynamic
+    }
+    //fallback to dynamic
+    return new DynamicType_1.DynamicType();
+}
+exports.getBscTypeFromExpression = getBscTypeFromExpression;
 //# sourceMappingURL=Parser.js.map