brighterscript 1.0.0-alpha.1 → 1.0.0-alpha.13

package/dist/parser/Parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeFromVariableExpression = exports.getTypeFromCallExpression = exports.getBscTypeFromExpression = 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");
@@ -11,11 +11,11 @@ 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 LazyType_1 = require("../types/LazyType");
 const SymbolTable_1 = require("../SymbolTable");
 const ObjectType_1 = require("../types/ObjectType");
-const CustomType_1 = require("../types/CustomType");
 const ArrayType_1 = require("../types/ArrayType");
+const helpers_1 = require("../types/helpers");
+const _1 = require(".");
 class Parser {
     constructor() {
         /**
@@ -61,13 +61,13 @@ class Parser {
         this._references = undefined;
     }
     addPropertyHints(item) {
-        if (lexer_1.isToken(item)) {
+        if ((0, lexer_1.isToken)(item)) {
             const name = item.text;
             this._references.propertyHints[name.toLowerCase()] = name;
         }
         else {
             for (const member of item.elements) {
-                if (!reflection_1.isCommentStatement(member)) {
+                if (!(0, reflection_1.isCommentStatement)(member)) {
                     const name = member.keyToken.text;
                     if (!name.startsWith('"')) {
                         this._references.propertyHints[name.toLowerCase()] = name;
@@ -87,6 +87,9 @@ class Parser {
         var _a;
         return (_a = this.globalTerminators[this.globalTerminators.length - 1]) !== null && _a !== void 0 ? _a : [];
     }
+    /**
+     * Static wrapper around creating a new parser and parsing a list of tokens
+     */
     static parse(toParse, options) {
         let tokens;
         if (typeof toParse === 'string') {
@@ -132,7 +135,7 @@ class Parser {
                     !this.checkAny(...this.peekGlobalTerminators())) {
                     let dec = this.declaration();
                     if (dec) {
-                        if (!reflection_1.isAnnotationExpression(dec)) {
+                        if (!(0, reflection_1.isAnnotationExpression)(dec)) {
                             this.consumePendingAnnotations(dec);
                             body.statements.push(dec);
                             //ensure statement separator
@@ -181,18 +184,12 @@ class Parser {
     }
     declaration() {
         try {
-            if (this.check(lexer_1.TokenKind.Class)) {
-                return this.classDeclaration();
-            }
             if (this.checkAny(lexer_1.TokenKind.Sub, lexer_1.TokenKind.Function)) {
                 return this.functionDeclaration(false);
             }
             if (this.checkLibrary()) {
                 return this.libraryStatement();
             }
-            if (this.check(lexer_1.TokenKind.Namespace)) {
-                return this.namespaceStatement();
-            }
             if (this.check(lexer_1.TokenKind.At) && this.checkNext(lexer_1.TokenKind.Identifier)) {
                 return this.annotationExpression();
             }
@@ -213,13 +210,116 @@ class Parser {
             this.synchronize();
         }
     }
+    identifier(...additionalTokenKinds) {
+        const identifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...additionalTokenKinds);
+        // force the name into an identifier so the AST makes some sense
+        identifier.kind = lexer_1.TokenKind.Identifier;
+        return identifier;
+    }
+    /**
+     * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration`
+     */
+    interfaceFieldStatement() {
+        const name = this.identifier(...lexer_1.AllowedProperties);
+        let asToken = this.consumeToken(lexer_1.TokenKind.As);
+        let typeToken = this.typeToken();
+        const type = util_1.util.tokenToBscType(typeToken);
+        if (!type) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
+            throw this.lastDiagnosticAsError();
+        }
+        return new Statement_1.InterfaceFieldStatement(name, asToken, typeToken, type);
+    }
+    /**
+     * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration()`
+     */
+    interfaceMethodStatement() {
+        const functionType = this.advance();
+        const name = this.identifier(...lexer_1.AllowedProperties);
+        const leftParen = this.consumeToken(lexer_1.TokenKind.LeftParen);
+        const params = [];
+        const rightParen = this.consumeToken(lexer_1.TokenKind.RightParen);
+        let asToken = null;
+        let returnTypeToken = null;
+        if (this.check(lexer_1.TokenKind.As)) {
+            asToken = this.advance();
+            returnTypeToken = this.typeToken();
+            const returnType = util_1.util.tokenToBscType(returnTypeToken);
+            if (!returnType) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, returnTypeToken.text)), { range: returnTypeToken.range }));
+                throw this.lastDiagnosticAsError();
+            }
+        }
+        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeToken, util_1.util.tokenToBscType(returnTypeToken));
+    }
+    interfaceDeclaration() {
+        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(...this.allowedLocalIdentifiers);
+        let extendsToken;
+        let parentInterfaceName;
+        if (this.peek().text.toLowerCase() === 'extends') {
+            extendsToken = this.advance();
+            parentInterfaceName = this.getNamespacedVariableNameExpression();
+        }
+        this.consumeStatementSeparators();
+        //gather up all interface members (Fields, Methods)
+        let body = [];
+        while (this.checkAny(lexer_1.TokenKind.Comment, lexer_1.TokenKind.Identifier, lexer_1.TokenKind.At, ...lexer_1.AllowedProperties)) {
+            try {
+                let decl;
+                //collect leading annotations
+                if (this.check(lexer_1.TokenKind.At)) {
+                    this.annotationExpression();
+                }
+                //fields
+                if (this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties) && this.checkNext(lexer_1.TokenKind.As)) {
+                    decl = this.interfaceFieldStatement();
+                    //methods (function/sub keyword followed by opening paren)
+                }
+                else if (this.checkAny(lexer_1.TokenKind.Function, lexer_1.TokenKind.Sub) && this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties)) {
+                    decl = this.interfaceMethodStatement();
+                    //comments
+                }
+                else if (this.check(lexer_1.TokenKind.Comment)) {
+                    decl = this.commentStatement();
+                }
+                if (decl) {
+                    this.consumePendingAnnotations(decl);
+                    body.push(decl);
+                }
+                else {
+                    //we didn't find a declaration...flag tokens until next line
+                    this.flagUntil(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Eof);
+                }
+            }
+            catch (e) {
+                //throw out any failed members and move on to the next line
+                this.flagUntil(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Eof);
+            }
+            //ensure statement separator
+            this.consumeStatementSeparators();
+            //break out of this loop if we encountered the `EndInterface` token not followed by `as`
+            if (this.check(lexer_1.TokenKind.EndInterface) && !this.checkNext(lexer_1.TokenKind.As)) {
+                break;
+            }
+        }
+        //consume the final `end interface` token
+        const endInterfaceToken = this.consumeToken(lexer_1.TokenKind.EndInterface);
+        this.consumeStatementSeparators();
+        const statement = new Statement_1.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endInterfaceToken, this.currentNamespaceName);
+        this._references.interfaceStatements.push(statement);
+        this.exitAnnotationBlock(parentAnnotations);
+        return statement;
+    }
     /**
      * A BrighterScript class declaration
      */
     classDeclaration() {
         this.warnIfNotBrighterScriptMode('class declarations');
         const parentAnnotations = this.enterAnnotationBlock();
-        let classKeyword = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassKeyword(), lexer_1.TokenKind.Class);
+        let classKeyword = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(lexer_1.TokenKind.Class), lexer_1.TokenKind.Class);
         let extendsKeyword;
         let parentClassName;
         //get the class name
@@ -250,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
@@ -289,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;
@@ -303,7 +406,7 @@ class Parser {
             asToken = this.advance();
             fieldType = this.typeToken();
             //no field type specified
-            if (!util_1.util.tokenToBscType(fieldType) && !this.check(lexer_1.TokenKind.Identifier)) {
+            if (!util_1.util.tokenToBscType(fieldType, true, this.currentNamespaceName)) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedValidTypeToFollowAsKeyword()), { range: this.peek().range }));
             }
         }
@@ -314,9 +417,9 @@ 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) {
+    functionDeclaration(isAnonymous, checkIdentifier = true, forClassMethod = false) {
         var _a, _b, _c, _d;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
@@ -377,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 }));
                 }
             }
@@ -397,7 +500,7 @@ class Parser {
                 this.currentFunctionExpression.childFunctionExpressions.push(func);
             }
             // add the function to the relevant symbol tables
-            if (!isAnonymous) {
+            if (!isAnonymous && !forClassMethod) {
                 const funcType = func.getFunctionType();
                 funcType.setName(name.text);
                 // add the function as declared to the current namespace's table
@@ -449,18 +552,12 @@ class Parser {
             this.callExpressions = previousCallExpressions;
         }
     }
-    identifier() {
-        const identifier = this.advance();
-        // force the name into an identifier so the AST makes some sense
-        identifier.kind = lexer_1.TokenKind.Identifier;
-        return identifier;
-    }
     functionParameter() {
         if (!this.checkAny(lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedParameterNameButFound(this.peek().text)), { range: this.peek().range }));
             throw this.lastDiagnosticAsError();
         }
-        const name = this.identifier();
+        const name = this.identifier(...lexer_1.AllowedLocalIdentifiers);
         let typeToken;
         let defaultValue;
         let equalsToken;
@@ -474,17 +571,20 @@ 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();
             }
         }
         let type;
         if (typeToken) {
-            type = util_1.util.tokenToBscType(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();
@@ -492,7 +592,7 @@ class Parser {
         return new Expression_1.FunctionParameterExpression(name, type, equalsToken, defaultValue, asToken, typeToken, this.currentNamespaceName);
     }
     assignment() {
-        let name = this.identifier();
+        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 }));
@@ -596,6 +696,16 @@ class Parser {
             this.checkAnyNext(...lexer_1.AssignmentOperators)) {
             return this.assignment();
         }
+        //some BrighterScript keywords are allowed as a local identifiers, so we need to check for them AFTER the assignment check
+        if (this.check(lexer_1.TokenKind.Interface)) {
+            return this.interfaceDeclaration();
+        }
+        if (this.check(lexer_1.TokenKind.Class)) {
+            return this.classDeclaration();
+        }
+        if (this.check(lexer_1.TokenKind.Namespace)) {
+            return this.namespaceStatement();
+        }
         // TODO: support multi-statements
         return this.setStatement();
     }
@@ -653,7 +763,7 @@ class Parser {
     }
     forEachStatement() {
         let forEach = this.advance();
-        let name = this.identifier();
+        let name = this.identifier(...this.allowedLocalIdentifiers);
         let maybeIn = this.peek();
         if (this.check(lexer_1.TokenKind.Identifier) && maybeIn.text.toLowerCase() === 'in') {
             this.advance();
@@ -674,7 +784,7 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         let endFor = this.advance();
-        //TODO infer type from `target`
+        //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);
@@ -741,7 +851,7 @@ class Parser {
             expr = new Expression_1.VariableExpression(firstIdentifier, null);
             //consume multiple dot identifiers (i.e. `Name.Space.Can.Have.Many.Parts`)
             while (this.check(lexer_1.TokenKind.Dot)) {
-                let dot = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(this.peek().text), lexer_1.TokenKind.Dot);
+                let dot = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), lexer_1.TokenKind.Dot);
                 if (!dot) {
                     break;
                 }
@@ -762,7 +872,7 @@ class Parser {
     flagUntil(...stopTokens) {
         while (!this.checkAny(...stopTokens) && !this.isAtEnd()) {
             let token = this.advance();
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(token.text)), { range: token.range }));
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(token.text)), { range: token.range }));
         }
     }
     /**
@@ -829,7 +939,7 @@ class Parser {
         while (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
             this.advance();
         }
-        const colonToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedTokenAButFoundTokenB(lexer_1.TokenKind.Colon, this.peek().text), lexer_1.TokenKind.Colon);
+        const colonToken = this.tryConsumeToken(lexer_1.TokenKind.Colon);
         //consume newlines
         while (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
             this.advance();
@@ -847,6 +957,12 @@ class Parser {
         const alternate = this.expression();
         return new Expression_1.NullCoalescingExpression(test, questionQuestionToken, alternate);
     }
+    regexLiteralExpression() {
+        this.warnIfNotBrighterScriptMode('regular expression literal');
+        return new _1.RegexLiteralExpression({
+            regexLiteral: this.advance()
+        });
+    }
     templateString(isTagged) {
         this.warnIfNotBrighterScriptMode('template string');
         //get the tag name
@@ -1047,7 +1163,7 @@ class Parser {
                     throw this.lastDiagnosticAsError();
                 }
             }
-            if (!elseBranch || !reflection_1.isIfStatement(elseBranch)) {
+            if (!elseBranch || !(0, reflection_1.isIfStatement)(elseBranch)) {
                 //enforce newline at the end of the inline if statement
                 const peek = this.peek();
                 if (peek.kind !== lexer_1.TokenKind.Newline && peek.kind !== lexer_1.TokenKind.Comment && !this.isAtEnd()) {
@@ -1079,7 +1195,7 @@ class Parser {
                     this.ensureNewLineOrColon();
                 }
             }
-            if (!reflection_1.isIfStatement(elseBranch)) {
+            if (!(0, reflection_1.isIfStatement)(elseBranch)) {
                 if (this.check(lexer_1.TokenKind.EndIf)) {
                     endIfToken = this.advance();
                 }
@@ -1128,7 +1244,7 @@ class Parser {
     //ensure each statement of an inline block is single-line
     ensureInline(statements) {
         for (const stat of statements) {
-            if (reflection_1.isIfStatement(stat) && !stat.isInline) {
+            if ((0, reflection_1.isIfStatement)(stat) && !stat.isInline) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement()), { range: stat.range }));
             }
         }
@@ -1143,6 +1259,7 @@ class Parser {
             return undefined;
         }
         statements.push(statement);
+        const startingRange = statement.range;
         //look for colon statement separator
         let foundColon = false;
         while (this.match(lexer_1.TokenKind.Colon)) {
@@ -1161,10 +1278,10 @@ class Parser {
             else {
                 //error: colon before next keyword
                 const colon = this.previous();
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(colon.text)), { range: colon.range }));
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(colon.text)), { range: colon.range }));
             }
         }
-        return new Statement_1.Block(statements, this.peek().range);
+        return new Statement_1.Block(statements, startingRange);
     }
     expressionStatement(expr) {
         let expressionStart = this.peek();
@@ -1174,13 +1291,13 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.consecutiveIncrementDecrementOperatorsAreNotAllowed()), { range: this.peek().range }));
                 throw this.lastDiagnosticAsError();
             }
-            else if (reflection_1.isCallExpression(expr)) {
+            else if ((0, reflection_1.isCallExpression)(expr)) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.incrementDecrementOperatorsAreNotAllowedAsResultOfFunctionCall()), { range: expressionStart.range }));
                 throw this.lastDiagnosticAsError();
             }
             return new Statement_1.IncrementStatement(expr, operator);
         }
-        if (reflection_1.isCallExpression(expr) || reflection_1.isCallfuncExpression(expr)) {
+        if ((0, reflection_1.isCallExpression)(expr) || (0, reflection_1.isCallfuncExpression)(expr)) {
             return new Statement_1.ExpressionStatement(expr);
         }
         //at this point, it's probably an error. However, we recover a little more gracefully by creating an assignment
@@ -1195,20 +1312,22 @@ class Parser {
          * priority as standalone function calls though, so we can parse them in the same way.
          */
         let expr = this.call();
-        if (this.checkAny(...lexer_1.AssignmentOperators) && !(reflection_1.isCallExpression(expr))) {
+        if (this.checkAny(...lexer_1.AssignmentOperators) && !((0, reflection_1.isCallExpression)(expr))) {
             let left = expr;
             let operator = this.advance();
             let right = this.expression();
             // Create a dotted or indexed "set" based on the left-hand side's type
-            if (reflection_1.isIndexedGetExpression(left)) {
+            if ((0, reflection_1.isIndexedGetExpression)(left)) {
                 return new Statement_1.IndexedSetStatement(left.obj, left.index, operator.kind === lexer_1.TokenKind.Equal
                     ? right
                     : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare);
             }
-            else if (reflection_1.isDottedGetExpression(left)) {
-                return new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === lexer_1.TokenKind.Equal
+            else if ((0, reflection_1.isDottedGetExpression)(left)) {
+                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);
@@ -1232,11 +1351,11 @@ class Parser {
         }
         //print statements can be empty, so look for empty print conditions
         if (!values.length) {
-            let emptyStringLiteral = creators_1.createStringLiteral('');
+            let emptyStringLiteral = (0, creators_1.createStringLiteral)('');
             values.push(emptyStringLiteral);
         }
         let last = values[values.length - 1];
-        if (lexer_1.isToken(last)) {
+        if ((0, lexer_1.isToken)(last)) {
             // TODO: error, expected value
         }
         return new Statement_1.PrintStatement({ print: printKeyword }, values);
@@ -1315,7 +1434,7 @@ class Parser {
             let loopCurrent = this.current;
             let dec = this.declaration();
             if (dec) {
-                if (!reflection_1.isAnnotationExpression(dec)) {
+                if (!(0, reflection_1.isAnnotationExpression)(dec)) {
                     this.consumePendingAnnotations(dec);
                     statements.push(dec);
                 }
@@ -1468,7 +1587,7 @@ class Parser {
         this.warnIfNotBrighterScriptMode(`using 'new' keyword to construct a class`);
         let newToken = this.advance();
         let nameExpr = this.getNamespacedVariableNameExpression();
-        let leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(this.peek().text), lexer_1.TokenKind.LeftParen);
+        let leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), lexer_1.TokenKind.LeftParen);
         let call = this.finishCall(leftParen, nameExpr);
         //pop the call from the  callExpressions list because this is technically something else
         this.callExpressions.pop();
@@ -1548,7 +1667,7 @@ class Parser {
         }
         while (this.match(lexer_1.TokenKind.Newline)) { }
         const closingParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), lexer_1.TokenKind.RightParen);
-        if (reflection_1.isVariableExpression(callee)) {
+        if ((0, reflection_1.isVariableExpression)(callee)) {
             callee.isCalled = true;
         }
         let expression = new Expression_1.CallExpression(callee, openingParen, closingParen, args, this.currentNamespaceName);
@@ -1560,7 +1679,7 @@ class Parser {
     /**
      * Tries to get the next token as a type
      * Allows for built-in types (double, string, etc.) or namespaced custom types in Brighterscript mode
-     * Will always return a token of whatever is next to be parsed
+     * Will  return a token of whatever is next to be parsed (unless `advanceIfUnknown` is false, in which case undefined will be returned instead
      */
     typeToken() {
         let typeToken;
@@ -1572,7 +1691,7 @@ class Parser {
             try {
                 // see if we can get a namespaced identifer
                 const qualifiedType = this.getNamespacedVariableNameExpression();
-                typeToken = creators_1.createToken(lexer_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
+                typeToken = (0, creators_1.createToken)(lexer_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
             }
             catch (_a) {
                 //could not get an identifier - just get whatever's next
@@ -1659,26 +1778,33 @@ class Parser {
                 while (this.match(lexer_1.TokenKind.Newline)) {
                 }
                 if (!this.match(lexer_1.TokenKind.RightCurlyBrace)) {
+                    let lastAAMember;
                     if (this.check(lexer_1.TokenKind.Comment)) {
+                        lastAAMember = null;
                         members.push(new Statement_1.CommentStatement([this.advance()]));
                     }
                     else {
                         let k = key();
                         let expr = this.expression();
-                        members.push(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)) {
+                        // collect comma at end of expression
+                        if (lastAAMember && this.checkPrevious(lexer_1.TokenKind.Comma)) {
+                            lastAAMember.commaToken = this.previous();
+                        }
                         //check for comment at the end of the current line
                         if (this.check(lexer_1.TokenKind.Comment) || this.checkPrevious(lexer_1.TokenKind.Comment)) {
                             let token = this.checkPrevious(lexer_1.TokenKind.Comment) ? this.previous() : this.advance();
                             members.push(new Statement_1.CommentStatement([token]));
                         }
                         else {
-                            while (this.matchAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon)) {
-                            }
+                            this.consumeStatementSeparators(true);
                             //check for a comment on its own line
                             if (this.check(lexer_1.TokenKind.Comment) || this.checkPrevious(lexer_1.TokenKind.Comment)) {
                                 let token = this.checkPrevious(lexer_1.TokenKind.Comment) ? this.previous() : this.advance();
+                                lastAAMember = null;
                                 members.push(new Statement_1.CommentStatement([token]));
                                 continue;
                             }
@@ -1687,13 +1813,15 @@ class Parser {
                             }
                             let k = key();
                             let expr = this.expression();
-                            members.push(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):
@@ -1703,6 +1831,8 @@ class Parser {
                 return new Expression_1.VariableExpression(token, this.currentNamespaceName);
             case this.checkAny(lexer_1.TokenKind.Function, lexer_1.TokenKind.Sub):
                 return this.anonymousFunction();
+            case this.check(lexer_1.TokenKind.RegexLiteral):
+                return this.regexLiteralExpression();
             case this.check(lexer_1.TokenKind.Comment):
                 return new Statement_1.CommentStatement([this.advance()]);
             default:
@@ -1712,7 +1842,7 @@ class Parser {
                     //something went wrong...throw an error so the upstream processor can scrap this line and move on
                 }
                 else {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(this.peek().text)), { range: this.peek().range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text)), { range: this.peek().range }));
                     throw this.lastDiagnosticAsError();
                 }
         }
@@ -1754,6 +1884,9 @@ class Parser {
             throw error;
         }
     }
+    consumeToken(tokenKind) {
+        return this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(tokenKind), tokenKind);
+    }
     /**
      * Consume, or add a message if not found. But then continue and return undefined
      */
@@ -1765,6 +1898,9 @@ class Parser {
         }
         this.diagnostics.push(Object.assign(Object.assign({}, diagnostic), { range: this.peek().range }));
     }
+    tryConsumeToken(tokenKind) {
+        return this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(tokenKind), tokenKind);
+    }
     consumeStatementSeparators(optional = false) {
         //a comment or EOF mark the end of the statement
         if (this.isAtEnd() || this.check(lexer_1.TokenKind.Comment)) {
@@ -1861,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.
@@ -1869,7 +2234,7 @@ class Parser {
     findReferences() {
         this._references = new References();
         //gather up all the top-level statements
-        this.ast.walk(visitors_1.createVisitor({
+        this.ast.walk((0, visitors_1.createVisitor)({
             ClassStatement: s => {
                 this._references.classStatements.push(s);
             },
@@ -1891,12 +2256,12 @@ class Parser {
             walkMode: visitors_1.WalkMode.visitStatements
         });
         let func;
-        let visitor = visitors_1.createVisitor({
+        let visitor = (0, visitors_1.createVisitor)({
             AssignmentStatement: s => {
                 this._references.assignmentStatements.push(s);
             },
             FunctionExpression: (expression, parent) => {
-                if (!reflection_1.isClassMethodStatement(parent)) {
+                if (!(0, reflection_1.isClassMethodStatement)(parent)) {
                     this._references.functionExpressions.push(expression);
                 }
             },
@@ -1922,6 +2287,18 @@ class Parser {
             });
         }
     }
+    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() {
     }
 }
@@ -1935,8 +2312,11 @@ class References {
     constructor() {
         this.assignmentStatements = [];
         this.classStatements = [];
+        this.dottedSetStatements = [];
+        this.aaLiterals = [];
         this.functionExpressions = [];
         this.functionStatements = [];
+        this.interfaceStatements = [];
         this.importStatements = [];
         this.libraryStatements = [];
         this.namespaceStatements = [];
@@ -1964,8 +2344,23 @@ class References {
         }
         return this._functionStatementLookup;
     }
+    get interfaceStatementLookup() {
+        if (!this._interfaceStatementLookup) {
+            this._interfaceStatementLookup = new Map();
+            for (const stmt of this.interfaceStatements) {
+                this._interfaceStatementLookup.set(stmt.fullName.toLowerCase(), stmt);
+            }
+        }
+        return this._interfaceStatementLookup;
+    }
 }
 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');
@@ -1980,32 +2375,34 @@ class CancelStatementError extends Error {
  */
 function getBscTypeFromExpression(expression, functionExpression) {
     try {
-        //function
-        if (reflection_1.isFunctionExpression(expression)) {
+        if ((0, reflection_1.isFunctionExpression)(expression)) {
             return expression.getFunctionType();
             //literal
         }
-        else if (reflection_1.isLiteralExpression(expression)) {
+        else if ((0, reflection_1.isLiteralExpression)(expression)) {
             return expression.type;
             //Associative array literal
         }
-        else if (reflection_1.isAALiteralExpression(expression)) {
-            return new ObjectType_1.ObjectType();
+        else if ((0, reflection_1.isAALiteralExpression)(expression)) {
+            return new ObjectType_1.ObjectType(expression.memberTable);
             //Array literal
         }
-        else if (reflection_1.isArrayLiteralExpression(expression)) {
+        else if ((0, reflection_1.isArrayLiteralExpression)(expression)) {
             return new ArrayType_1.ArrayType();
             //function call
         }
-        else if (reflection_1.isNewExpression(expression)) {
-            return new CustomType_1.CustomType(expression.className.getName(ParseMode.BrighterScript));
+        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 (reflection_1.isCallExpression(expression)) {
-            return getTypeFromCallExpression(expression, functionExpression);
+        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 (reflection_1.isVariableExpression(expression)) {
-            return getTypeFromVariableExpression(expression, functionExpression);
+        else if ((0, reflection_1.isDottedGetExpression)(expression)) {
+            return (0, helpers_1.getTypeFromDottedGetExpression)(expression, functionExpression);
         }
     }
     catch (e) {
@@ -2015,56 +2412,4 @@ function getBscTypeFromExpression(expression, functionExpression) {
     return new DynamicType_1.DynamicType();
 }
 exports.getBscTypeFromExpression = getBscTypeFromExpression;
-/**
- * Gets the return type of a function, taking into account that the function may not have been declared yet
- * If the callee already exists in symbol table, use that return type
- * otherwise, make a lazy type which will not compute its type until the file is done parsing
- *
- * @param call the Expression to process
- * @param functionExpression the wrapping function expression
- * @return the best guess type of that expression
- */
-function getTypeFromCallExpression(call, functionExpression) {
-    var _a;
-    let calleeName = (_a = call.callee.name.text) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-    if (calleeName) {
-        // i
-        const currentKnownType = functionExpression.symbolTable.getSymbolType(calleeName);
-        if (reflection_1.isFunctionType(currentKnownType)) {
-            return currentKnownType.returnType;
-        }
-        if (!reflection_1.isUninitializedType(currentKnownType)) {
-            // this will probably only happen if a functionName has been assigned to something else previously?
-            return currentKnownType;
-        }
-        return new LazyType_1.LazyType(() => {
-            const futureType = functionExpression.symbolTable.getSymbolType(calleeName);
-            if (reflection_1.isFunctionType(futureType)) {
-                return futureType.returnType;
-            }
-            return futureType;
-        });
-    }
-}
-exports.getTypeFromCallExpression = getTypeFromCallExpression;
-/**
- * Gets the type of a variable
- * if it already exists in symbol table, use that type
- * otherwise defer the type until first read, which will allow us to derive types from variables defined after this one (like from a loop perhaps)
- *
- * @param variable the Expression to process
- * @param functionExpression the wrapping function expression
- * @return the best guess type of that expression
- */
-function getTypeFromVariableExpression(variable, functionExpression) {
-    let variableName = variable.name.text.toLowerCase();
-    const currentKnownType = functionExpression.symbolTable.getSymbolType(variableName);
-    if (!reflection_1.isUninitializedType(currentKnownType)) {
-        return currentKnownType;
-    }
-    return new LazyType_1.LazyType(() => {
-        return functionExpression.symbolTable.getSymbolType(variableName);
-    });
-}
-exports.getTypeFromVariableExpression = getTypeFromVariableExpression;
 //# sourceMappingURL=Parser.js.map