brighterscript 1.0.0-alpha.11 → 1.0.0-alpha.15

package/dist/parser/Parser.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBscTypeFromExpression = exports.TokenUsage = exports.References = exports.ParseMode = exports.Parser = void 0;
-const lexer_1 = require("../lexer");
+const Token_1 = require("../lexer/Token");
+const Lexer_1 = require("../lexer/Lexer");
+const TokenKind_1 = require("../lexer/TokenKind");
 const Statement_1 = require("./Statement");
 const DiagnosticMessages_1 = require("../DiagnosticMessages");
 const util_1 = require("../util");
@@ -10,12 +12,12 @@ const Logger_1 = require("../Logger");
 const reflection_1 = require("../astUtils/reflection");
 const visitors_1 = require("../astUtils/visitors");
 const creators_1 = require("../astUtils/creators");
+const Cache_1 = require("../Cache");
 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(".");
+const SymbolTable_1 = require("../SymbolTable");
+const ObjectType_1 = require("../types/ObjectType");
 class Parser {
     constructor() {
         /**
@@ -61,7 +63,7 @@ class Parser {
         this._references = undefined;
     }
     addPropertyHints(item) {
-        if ((0, lexer_1.isToken)(item)) {
+        if ((0, Token_1.isToken)(item)) {
             const name = item.text;
             this._references.propertyHints[name.toLowerCase()] = name;
         }
@@ -93,7 +95,7 @@ class Parser {
     static parse(toParse, options) {
         let tokens;
         if (typeof toParse === 'string') {
-            tokens = lexer_1.Lexer.scan(toParse).tokens;
+            tokens = Lexer_1.Lexer.scan(toParse).tokens;
         }
         else {
             tokens = toParse;
@@ -111,9 +113,9 @@ class Parser {
         this.tokens = tokens;
         this.options = this.sanitizeParseOptions(options);
         this.allowedLocalIdentifiers = [
-            ...lexer_1.AllowedLocalIdentifiers,
+            ...TokenKind_1.AllowedLocalIdentifiers,
             //when in plain brightscript mode, the BrighterScript source literals can be used as regular variables
-            ...(this.options.mode === ParseMode.BrightScript ? lexer_1.BrighterScriptSourceLiterals : [])
+            ...(this.options.mode === ParseMode.BrightScript ? TokenKind_1.BrighterScriptSourceLiterals : [])
         ];
         this.current = 0;
         this.diagnostics = [];
@@ -184,16 +186,16 @@ class Parser {
     }
     declaration() {
         try {
-            if (this.checkAny(lexer_1.TokenKind.Sub, lexer_1.TokenKind.Function)) {
+            if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
                 return this.functionDeclaration(false);
             }
             if (this.checkLibrary()) {
                 return this.libraryStatement();
             }
-            if (this.check(lexer_1.TokenKind.At) && this.checkNext(lexer_1.TokenKind.Identifier)) {
+            if (this.check(TokenKind_1.TokenKind.At) && this.checkNext(TokenKind_1.TokenKind.Identifier)) {
                 return this.annotationExpression();
             }
-            if (this.check(lexer_1.TokenKind.Comment)) {
+            if (this.check(TokenKind_1.TokenKind.Comment)) {
                 return this.commentStatement();
             }
             //catch certain global terminators to prevent unnecessary lookahead (i.e. like `end namespace`, no need to continue)
@@ -210,18 +212,39 @@ class Parser {
             this.synchronize();
         }
     }
+    /**
+     * Try to get an identifier. If not found, add diagnostic and return undefined
+     */
+    tryIdentifier(...additionalTokenKinds) {
+        const identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...additionalTokenKinds);
+        if (identifier) {
+            // force the name into an identifier so the AST makes some sense
+            identifier.kind = TokenKind_1.TokenKind.Identifier;
+            return identifier;
+        }
+    }
     identifier(...additionalTokenKinds) {
-        const identifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...additionalTokenKinds);
+        const identifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...additionalTokenKinds);
         // force the name into an identifier so the AST makes some sense
-        identifier.kind = lexer_1.TokenKind.Identifier;
+        identifier.kind = TokenKind_1.TokenKind.Identifier;
         return identifier;
     }
+    enumMemberStatement() {
+        const statement = new Statement_1.EnumMemberStatement({});
+        statement.tokens.name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+        //look for `= SOME_EXPRESSION`
+        if (this.check(TokenKind_1.TokenKind.Equal)) {
+            statement.tokens.equal = this.advance();
+            statement.value = this.expression();
+        }
+        return statement;
+    }
     /**
      * 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);
+        const name = this.identifier(...TokenKind_1.AllowedProperties);
+        let asToken = this.consumeToken(TokenKind_1.TokenKind.As);
         let typeToken = this.typeToken();
         const type = util_1.util.tokenToBscType(typeToken);
         if (!type) {
@@ -235,13 +258,13 @@ class Parser {
      */
     interfaceMethodStatement() {
         const functionType = this.advance();
-        const name = this.identifier(...lexer_1.AllowedProperties);
-        const leftParen = this.consumeToken(lexer_1.TokenKind.LeftParen);
+        const name = this.identifier(...TokenKind_1.AllowedProperties);
+        const leftParen = this.consumeToken(TokenKind_1.TokenKind.LeftParen);
         const params = [];
-        const rightParen = this.consumeToken(lexer_1.TokenKind.RightParen);
+        const rightParen = this.consumeToken(TokenKind_1.TokenKind.RightParen);
         let asToken = null;
         let returnTypeToken = null;
-        if (this.check(lexer_1.TokenKind.As)) {
+        if (this.check(TokenKind_1.TokenKind.As)) {
             asToken = this.advance();
             returnTypeToken = this.typeToken();
             const returnType = util_1.util.tokenToBscType(returnTypeToken);
@@ -255,7 +278,7 @@ class Parser {
     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 interfaceToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Interface), TokenKind_1.TokenKind.Interface);
         const nameToken = this.identifier(...this.allowedLocalIdentifiers);
         let extendsToken;
         let parentInterfaceName;
@@ -266,23 +289,23 @@ class Parser {
         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)) {
+        while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
             try {
                 let decl;
                 //collect leading annotations
-                if (this.check(lexer_1.TokenKind.At)) {
+                if (this.check(TokenKind_1.TokenKind.At)) {
                     this.annotationExpression();
                 }
                 //fields
-                if (this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties) && this.checkNext(lexer_1.TokenKind.As)) {
+                if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties) && this.checkNext(TokenKind_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)) {
+                else if (this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub) && this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
                     decl = this.interfaceMethodStatement();
                     //comments
                 }
-                else if (this.check(lexer_1.TokenKind.Comment)) {
+                else if (this.check(TokenKind_1.TokenKind.Comment)) {
                     decl = this.commentStatement();
                 }
                 if (decl) {
@@ -291,39 +314,87 @@ class Parser {
                 }
                 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);
+                    this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_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);
+                this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_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)) {
+            if (this.check(TokenKind_1.TokenKind.EndInterface) && !this.checkNext(TokenKind_1.TokenKind.As)) {
                 break;
             }
         }
         //consume the final `end interface` token
-        const endInterfaceToken = this.consumeToken(lexer_1.TokenKind.EndInterface);
-        this.consumeStatementSeparators();
+        const endInterfaceToken = this.consumeToken(TokenKind_1.TokenKind.EndInterface);
         const statement = new Statement_1.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endInterfaceToken, this.currentNamespaceName);
         this._references.interfaceStatements.push(statement);
         this.exitAnnotationBlock(parentAnnotations);
         return statement;
     }
+    enumDeclaration() {
+        const result = new Statement_1.EnumStatement({}, [], this.currentNamespaceName);
+        this.warnIfNotBrighterScriptMode('enum declarations');
+        const parentAnnotations = this.enterAnnotationBlock();
+        result.tokens.enum = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
+        result.tokens.name = this.tryIdentifier();
+        this.consumeStatementSeparators();
+        //gather up all members
+        while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
+            try {
+                let decl;
+                //collect leading annotations
+                if (this.check(TokenKind_1.TokenKind.At)) {
+                    this.annotationExpression();
+                }
+                //members
+                if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+                    decl = this.enumMemberStatement();
+                    //comments
+                }
+                else if (this.check(TokenKind_1.TokenKind.Comment)) {
+                    decl = this.commentStatement();
+                }
+                if (decl) {
+                    this.consumePendingAnnotations(decl);
+                    result.body.push(decl);
+                }
+                else {
+                    //we didn't find a declaration...flag tokens until next line
+                    this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
+                }
+            }
+            catch (e) {
+                //throw out any failed members and move on to the next line
+                this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
+            }
+            //ensure statement separator
+            this.consumeStatementSeparators();
+            //break out of this loop if we encountered the `EndEnum` token
+            if (this.check(TokenKind_1.TokenKind.EndEnum)) {
+                break;
+            }
+        }
+        //consume the final `end interface` token
+        result.tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
+        this._references.enumStatements.push(result);
+        this.exitAnnotationBlock(parentAnnotations);
+        return result;
+    }
     /**
      * A BrighterScript class declaration
      */
     classDeclaration() {
         this.warnIfNotBrighterScriptMode('class declarations');
         const parentAnnotations = this.enterAnnotationBlock();
-        let classKeyword = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(lexer_1.TokenKind.Class), lexer_1.TokenKind.Class);
+        let classKeyword = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Class), TokenKind_1.TokenKind.Class);
         let extendsKeyword;
         let parentClassName;
         //get the class name
-        let className = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('class'), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+        let className = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('class'), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
         //see if the class inherits from parent
         if (this.peek().text.toLowerCase() === 'extends') {
             extendsKeyword = this.advance();
@@ -333,14 +404,14 @@ class Parser {
         this.consumeStatementSeparators();
         //gather up all class members (Fields, Methods)
         let body = [];
-        while (this.checkAny(lexer_1.TokenKind.Public, lexer_1.TokenKind.Protected, lexer_1.TokenKind.Private, lexer_1.TokenKind.Function, lexer_1.TokenKind.Sub, lexer_1.TokenKind.Comment, lexer_1.TokenKind.Identifier, lexer_1.TokenKind.At, ...lexer_1.AllowedProperties)) {
+        while (this.checkAny(TokenKind_1.TokenKind.Public, TokenKind_1.TokenKind.Protected, TokenKind_1.TokenKind.Private, TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
             try {
                 let decl;
                 let accessModifier;
-                if (this.check(lexer_1.TokenKind.At)) {
+                if (this.check(TokenKind_1.TokenKind.At)) {
                     this.annotationExpression();
                 }
-                if (this.checkAny(lexer_1.TokenKind.Public, lexer_1.TokenKind.Protected, lexer_1.TokenKind.Private)) {
+                if (this.checkAny(TokenKind_1.TokenKind.Public, TokenKind_1.TokenKind.Protected, TokenKind_1.TokenKind.Private)) {
                     //use actual access modifier
                     accessModifier = this.advance();
                 }
@@ -349,7 +420,7 @@ class Parser {
                     overrideKeyword = this.advance();
                 }
                 //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))) {
+                if (this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub) || (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties) && this.checkNext(TokenKind_1.TokenKind.LeftParen))) {
                     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();
@@ -362,7 +433,7 @@ class Parser {
                     functionStatement.func.functionStatement = decl;
                     //fields
                 }
-                else if (this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties)) {
+                else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
                     decl = this.classFieldDeclaration(accessModifier);
                     //class fields cannot be overridden
                     if (overrideKeyword) {
@@ -370,7 +441,7 @@ class Parser {
                     }
                     //comments
                 }
-                else if (this.check(lexer_1.TokenKind.Comment)) {
+                else if (this.check(TokenKind_1.TokenKind.Comment)) {
                     decl = this.commentStatement();
                 }
                 if (decl) {
@@ -380,13 +451,13 @@ class Parser {
             }
             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);
+                this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
             }
             //ensure statement separator
             this.consumeStatementSeparators();
         }
         let endingKeyword = this.advance();
-        if (endingKeyword.kind !== lexer_1.TokenKind.EndClass) {
+        if (endingKeyword.kind !== TokenKind_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, this.currentSymbolTable);
@@ -398,11 +469,11 @@ class Parser {
         return result;
     }
     classFieldDeclaration(accessModifier) {
-        let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+        let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         let asToken;
         let fieldType;
         //look for `as SOME_TYPE`
-        if (this.check(lexer_1.TokenKind.As)) {
+        if (this.check(TokenKind_1.TokenKind.As)) {
             asToken = this.advance();
             fieldType = this.typeToken();
             //no field type specified
@@ -413,7 +484,7 @@ class Parser {
         let initialValue;
         let equal;
         //if there is a field initializer
-        if (this.check(lexer_1.TokenKind.Equal)) {
+        if (this.check(TokenKind_1.TokenKind.Equal)) {
             equal = this.advance();
             initialValue = this.expression();
         }
@@ -427,14 +498,14 @@ class Parser {
             //track depth to help certain statements need to know if they are contained within a function body
             this.namespaceAndFunctionDepth++;
             let functionType;
-            if (this.checkAny(lexer_1.TokenKind.Sub, lexer_1.TokenKind.Function)) {
+            if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
                 functionType = this.advance();
             }
             else {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingCallableKeyword()), { range: this.peek().range }));
                 functionType = {
                     isReserved: true,
-                    kind: lexer_1.TokenKind.Function,
+                    kind: TokenKind_1.TokenKind.Function,
                     text: 'function',
                     //zero-length location means derived
                     range: {
@@ -444,16 +515,16 @@ class Parser {
                     leadingWhitespace: ''
                 };
             }
-            let isSub = (functionType === null || functionType === void 0 ? void 0 : functionType.kind) === lexer_1.TokenKind.Sub;
+            let isSub = (functionType === null || functionType === void 0 ? void 0 : functionType.kind) === TokenKind_1.TokenKind.Sub;
             let functionTypeText = isSub ? 'sub' : 'function';
             let name;
             let leftParen;
             if (isAnonymous) {
-                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallable(functionTypeText), lexer_1.TokenKind.LeftParen);
+                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallable(functionTypeText), TokenKind_1.TokenKind.LeftParen);
             }
             else {
-                name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedNameAfterCallableKeyword(functionTypeText), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
-                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallableName(functionTypeText), lexer_1.TokenKind.LeftParen);
+                name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedNameAfterCallableKeyword(functionTypeText), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallableName(functionTypeText), TokenKind_1.TokenKind.LeftParen);
                 //prevent functions from ending with type designators
                 let lastChar = name.text[name.text.length - 1];
                 if (['$', '%', '!', '#', '&'].includes(lastChar)) {
@@ -461,23 +532,23 @@ class Parser {
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionNameCannotEndWithTypeDesignator(functionTypeText, name.text, lastChar)), { range: name.range }));
                 }
                 //flag functions with keywords for names (only for standard functions)
-                if (checkIdentifier && lexer_1.DisallowedFunctionIdentifiersText.has(name.text.toLowerCase())) {
+                if (checkIdentifier && TokenKind_1.DisallowedFunctionIdentifiersText.has(name.text.toLowerCase())) {
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(name.text)), { range: name.range }));
                 }
             }
             let params = [];
             let asToken;
             let typeToken;
-            if (!this.check(lexer_1.TokenKind.RightParen)) {
+            if (!this.check(TokenKind_1.TokenKind.RightParen)) {
                 do {
                     if (params.length >= Expression_1.CallExpression.MaximumArguments) {
                         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableParameters(params.length, Expression_1.CallExpression.MaximumArguments)), { range: this.peek().range }));
                     }
                     params.push(this.functionParameter());
-                } while (this.match(lexer_1.TokenKind.Comma));
+                } while (this.match(TokenKind_1.TokenKind.Comma));
             }
             let rightParen = this.advance();
-            if (this.check(lexer_1.TokenKind.As)) {
+            if (this.check(TokenKind_1.TokenKind.As)) {
                 asToken = this.advance();
                 typeToken = this.typeToken();
                 if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript, this.currentNamespaceName)) {
@@ -529,7 +600,7 @@ class Parser {
             }
             // consume 'end sub' or 'end function'
             func.end = this.advance();
-            let expectedEndKind = isSub ? lexer_1.TokenKind.EndSub : lexer_1.TokenKind.EndFunction;
+            let expectedEndKind = isSub ? TokenKind_1.TokenKind.EndSub : TokenKind_1.TokenKind.EndFunction;
             //if `function` is ended with `end sub`, or `sub` is ended with `end function`, then
             //add an error but don't hard-fail so the AST can continue more gracefully
             if (func.end.kind !== expectedEndKind) {
@@ -553,22 +624,22 @@ class Parser {
         }
     }
     functionParameter() {
-        if (!this.checkAny(lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+        if (!this.checkAny(TokenKind_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(...lexer_1.AllowedLocalIdentifiers);
+        const name = this.identifier(...TokenKind_1.AllowedLocalIdentifiers);
         let typeToken;
         let defaultValue;
         let equalsToken;
         // parse argument default value
-        if (this.match(lexer_1.TokenKind.Equal)) {
+        if (this.match(TokenKind_1.TokenKind.Equal)) {
             equalsToken = this.previous();
             // it seems any expression is allowed here -- including ones that operate on other arguments!
             defaultValue = this.expression();
         }
         let asToken = null;
-        if (this.check(lexer_1.TokenKind.As)) {
+        if (this.check(TokenKind_1.TokenKind.As)) {
             asToken = this.advance();
             typeToken = this.typeToken();
             if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript, this.currentNamespaceName)) {
@@ -594,17 +665,20 @@ class Parser {
     assignment() {
         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())) {
+        if (TokenKind_1.DisallowedLocalIdentifiersText.has(name.text.toLowerCase())) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(name.text)), { range: name.range }));
         }
-        let operator = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOperatorAfterIdentifier(lexer_1.AssignmentOperators, name.text), ...lexer_1.AssignmentOperators);
+        let operator = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOperatorAfterIdentifier(TokenKind_1.AssignmentOperators, name.text), ...TokenKind_1.AssignmentOperators);
         let value = this.expression();
         let result;
-        if (operator.kind === lexer_1.TokenKind.Equal) {
+        if (operator.kind === TokenKind_1.TokenKind.Equal) {
             result = new Statement_1.AssignmentStatement(name, operator, value, this.currentFunctionExpression);
         }
         else {
             result = new Statement_1.AssignmentStatement(name, operator, new Expression_1.BinaryExpression(new Expression_1.VariableExpression(name, this.currentNamespaceName), operator, value), this.currentFunctionExpression);
+            //remove the right-hand-side expression from this assignment operator, and replace with the full assignment expression
+            this._references.expressions.delete(value);
+            this._references.expressions.add(result);
         }
         this._references.assignmentStatements.push(result);
         const assignmentType = getBscTypeFromExpression(result.value, this.currentFunctionExpression);
@@ -612,14 +686,14 @@ class Parser {
         return result;
     }
     checkLibrary() {
-        let isLibraryToken = this.check(lexer_1.TokenKind.Library);
+        let isLibraryToken = this.check(TokenKind_1.TokenKind.Library);
         //if we are at the top level, any line that starts with "library" should be considered a library statement
         if (this.isAtRootLevel() && isLibraryToken) {
             return true;
             //not at root level, library statements are all invalid here, but try to detect if the tokens look
             //like a library statement (and let the libraryStatement function handle emitting the diagnostics)
         }
-        else if (isLibraryToken && this.checkNext(lexer_1.TokenKind.StringLiteral)) {
+        else if (isLibraryToken && this.checkNext(TokenKind_1.TokenKind.StringLiteral)) {
             return true;
             //definitely not a library statement
         }
@@ -631,54 +705,54 @@ class Parser {
         if (this.checkLibrary()) {
             return this.libraryStatement();
         }
-        if (this.check(lexer_1.TokenKind.Import)) {
+        if (this.check(TokenKind_1.TokenKind.Import)) {
             return this.importStatement();
         }
-        if (this.check(lexer_1.TokenKind.Stop)) {
+        if (this.check(TokenKind_1.TokenKind.Stop)) {
             return this.stopStatement();
         }
-        if (this.check(lexer_1.TokenKind.If)) {
+        if (this.check(TokenKind_1.TokenKind.If)) {
             return this.ifStatement();
         }
         //`try` must be followed by a block, otherwise it could be a local variable
-        if (this.check(lexer_1.TokenKind.Try) && this.checkAnyNext(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Comment)) {
+        if (this.check(TokenKind_1.TokenKind.Try) && this.checkAnyNext(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
             return this.tryCatchStatement();
         }
-        if (this.check(lexer_1.TokenKind.Throw)) {
+        if (this.check(TokenKind_1.TokenKind.Throw)) {
             return this.throwStatement();
         }
-        if (this.checkAny(lexer_1.TokenKind.Print, lexer_1.TokenKind.Question)) {
+        if (this.checkAny(TokenKind_1.TokenKind.Print, TokenKind_1.TokenKind.Question)) {
             return this.printStatement();
         }
-        if (this.check(lexer_1.TokenKind.Dim)) {
+        if (this.check(TokenKind_1.TokenKind.Dim)) {
             return this.dimStatement();
         }
-        if (this.check(lexer_1.TokenKind.While)) {
+        if (this.check(TokenKind_1.TokenKind.While)) {
             return this.whileStatement();
         }
-        if (this.check(lexer_1.TokenKind.ExitWhile)) {
+        if (this.check(TokenKind_1.TokenKind.ExitWhile)) {
             return this.exitWhile();
         }
-        if (this.check(lexer_1.TokenKind.For)) {
+        if (this.check(TokenKind_1.TokenKind.For)) {
             return this.forStatement();
         }
-        if (this.check(lexer_1.TokenKind.ForEach)) {
+        if (this.check(TokenKind_1.TokenKind.ForEach)) {
             return this.forEachStatement();
         }
-        if (this.check(lexer_1.TokenKind.ExitFor)) {
+        if (this.check(TokenKind_1.TokenKind.ExitFor)) {
             return this.exitFor();
         }
-        if (this.check(lexer_1.TokenKind.End)) {
+        if (this.check(TokenKind_1.TokenKind.End)) {
             return this.endStatement();
         }
-        if (this.match(lexer_1.TokenKind.Return)) {
+        if (this.match(TokenKind_1.TokenKind.Return)) {
             return this.returnStatement();
         }
-        if (this.check(lexer_1.TokenKind.Goto)) {
+        if (this.check(TokenKind_1.TokenKind.Goto)) {
             return this.gotoStatement();
         }
         //does this line look like a label? (i.e.  `someIdentifier:` )
-        if (this.check(lexer_1.TokenKind.Identifier) && this.checkNext(lexer_1.TokenKind.Colon) && this.checkPrevious(lexer_1.TokenKind.Newline)) {
+        if (this.check(TokenKind_1.TokenKind.Identifier) && this.checkNext(TokenKind_1.TokenKind.Colon) && this.checkPrevious(TokenKind_1.TokenKind.Newline)) {
             try {
                 return this.labelStatement();
             }
@@ -692,20 +766,23 @@ class Parser {
         // BrightScript is like python, in that variables can be declared without a `var`,
         // `let`, (...) keyword. As such, we must check the token *after* an identifier to figure
         // out what to do with it.
-        if (this.checkAny(lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers) &&
-            this.checkAnyNext(...lexer_1.AssignmentOperators)) {
+        if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers) &&
+            this.checkAnyNext(...TokenKind_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)) {
+        if (this.check(TokenKind_1.TokenKind.Interface)) {
             return this.interfaceDeclaration();
         }
-        if (this.check(lexer_1.TokenKind.Class)) {
+        if (this.check(TokenKind_1.TokenKind.Class)) {
             return this.classDeclaration();
         }
-        if (this.check(lexer_1.TokenKind.Namespace)) {
+        if (this.check(TokenKind_1.TokenKind.Namespace)) {
             return this.namespaceStatement();
         }
+        if (this.check(TokenKind_1.TokenKind.Enum)) {
+            return this.enumDeclaration();
+        }
         // TODO: support multi-statements
         return this.setStatement();
     }
@@ -713,9 +790,9 @@ class Parser {
         const whileKeyword = this.advance();
         const condition = this.expression();
         this.consumeStatementSeparators();
-        const whileBlock = this.block(lexer_1.TokenKind.EndWhile);
+        const whileBlock = this.block(TokenKind_1.TokenKind.EndWhile);
         let endWhile;
-        if (!whileBlock || this.peek().kind !== lexer_1.TokenKind.EndWhile) {
+        if (!whileBlock || this.peek().kind !== TokenKind_1.TokenKind.EndWhile) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('while')), { range: this.peek().range }));
             if (!whileBlock) {
                 throw this.lastDiagnosticAsError();
@@ -738,7 +815,7 @@ class Parser {
         const finalValue = this.expression();
         let incrementExpression;
         let stepToken;
-        if (this.check(lexer_1.TokenKind.Step)) {
+        if (this.check(TokenKind_1.TokenKind.Step)) {
             stepToken = this.advance();
             incrementExpression = this.expression();
         }
@@ -746,9 +823,9 @@ class Parser {
             // BrightScript for/to/step loops default to a step of 1 if no `step` is provided
         }
         this.consumeStatementSeparators();
-        let body = this.block(lexer_1.TokenKind.EndFor, lexer_1.TokenKind.Next);
+        let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next);
         let endForToken;
-        if (!body || !this.checkAny(lexer_1.TokenKind.EndFor, lexer_1.TokenKind.Next)) {
+        if (!body || !this.checkAny(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next)) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop()), { range: this.peek().range }));
             if (!body) {
                 throw this.lastDiagnosticAsError();
@@ -765,7 +842,7 @@ class Parser {
         let forEach = this.advance();
         let name = this.identifier(...this.allowedLocalIdentifiers);
         let maybeIn = this.peek();
-        if (this.check(lexer_1.TokenKind.Identifier) && maybeIn.text.toLowerCase() === 'in') {
+        if (this.check(TokenKind_1.TokenKind.Identifier) && maybeIn.text.toLowerCase() === 'in') {
             this.advance();
         }
         else {
@@ -778,14 +855,17 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         this.consumeStatementSeparators();
-        let body = this.block(lexer_1.TokenKind.EndFor, lexer_1.TokenKind.Next);
+        let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next);
         if (!body) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop()), { range: this.peek().range }));
             throw this.lastDiagnosticAsError();
         }
         let endFor = this.advance();
-        //TODO TYPES infer type from `target`
-        const itemType = new DynamicType_1.DynamicType();
+        let itemType = new DynamicType_1.DynamicType();
+        const targetType = getBscTypeFromExpression(target, this.currentFunctionExpression);
+        if ((0, reflection_1.isArrayType)(targetType)) {
+            itemType = targetType.getDefaultType();
+        }
         this.currentSymbolTable.addSymbol(name.text, name.range, itemType);
         return new Statement_1.ForEachStatement(forEach, name, maybeIn, target, body, endFor);
     }
@@ -802,7 +882,7 @@ class Parser {
         }
         else {
             let comments = [this.advance()];
-            while (this.check(lexer_1.TokenKind.Newline) && this.checkNext(lexer_1.TokenKind.Comment)) {
+            while (this.check(TokenKind_1.TokenKind.Newline) && this.checkNext(TokenKind_1.TokenKind.Comment)) {
                 this.advance();
                 comments.push(this.advance());
             }
@@ -820,13 +900,13 @@ class Parser {
         //set the current namespace name
         let result = new Statement_1.NamespaceStatement(keyword, name, null, null, this.currentSymbolTable);
         this.currentNamespace = result;
-        this.globalTerminators.push([lexer_1.TokenKind.EndNamespace]);
+        this.globalTerminators.push([TokenKind_1.TokenKind.EndNamespace]);
         let body = this.body();
         this.globalTerminators.pop();
         //unset the current namespace name
         this.currentNamespace = undefined;
         let endKeyword;
-        if (this.check(lexer_1.TokenKind.EndNamespace)) {
+        if (this.check(TokenKind_1.TokenKind.EndNamespace)) {
             endKeyword = this.advance();
         }
         else {
@@ -843,24 +923,25 @@ class Parser {
      * Get an expression with identifiers separated by periods. Useful for namespaces and class extends
      */
     getNamespacedVariableNameExpression() {
-        let firstIdentifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(this.previous().text), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+        let firstIdentifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(this.previous().text), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
         let expr;
         if (firstIdentifier) {
             // force it into an identifier so the AST makes some sense
-            firstIdentifier.kind = lexer_1.TokenKind.Identifier;
-            expr = new Expression_1.VariableExpression(firstIdentifier, null);
+            firstIdentifier.kind = TokenKind_1.TokenKind.Identifier;
+            const varExpr = new Expression_1.VariableExpression(firstIdentifier, null);
+            expr = varExpr;
             //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.unexpectedToken(this.peek().text), lexer_1.TokenKind.Dot);
+            while (this.check(TokenKind_1.TokenKind.Dot)) {
+                let dot = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.Dot);
                 if (!dot) {
                     break;
                 }
-                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers, ...lexer_1.AllowedProperties);
+                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers, ...TokenKind_1.AllowedProperties);
                 if (!identifier) {
                     break;
                 }
                 // force it into an identifier so the AST makes some sense
-                identifier.kind = lexer_1.TokenKind.Identifier;
+                identifier.kind = TokenKind_1.TokenKind.Identifier;
                 expr = new Expression_1.DottedGetExpression(expr, identifier, dot);
             }
         }
@@ -892,7 +973,7 @@ class Parser {
         let libStatement = new Statement_1.LibraryStatement({
             library: this.advance(),
             //grab the next token only if it's a string
-            filePath: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('library'), lexer_1.TokenKind.StringLiteral)
+            filePath: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('library'), TokenKind_1.TokenKind.StringLiteral)
         });
         this._references.libraryStatements.push(libStatement);
         return libStatement;
@@ -901,20 +982,20 @@ class Parser {
         this.warnIfNotBrighterScriptMode('import statements');
         let importStatement = new Statement_1.ImportStatement(this.advance(), 
         //grab the next token only if it's a string
-        this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import'), lexer_1.TokenKind.StringLiteral));
+        this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import'), TokenKind_1.TokenKind.StringLiteral));
         this._references.importStatements.push(importStatement);
         return importStatement;
     }
     annotationExpression() {
         const atToken = this.advance();
-        const identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+        const identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         if (identifier) {
-            identifier.kind = lexer_1.TokenKind.Identifier;
+            identifier.kind = TokenKind_1.TokenKind.Identifier;
         }
         let annotation = new Expression_1.AnnotationExpression(atToken, identifier);
         this.pendingAnnotations.push(annotation);
         //optional arguments
-        if (this.check(lexer_1.TokenKind.LeftParen)) {
+        if (this.check(TokenKind_1.TokenKind.LeftParen)) {
             let leftParen = this.advance();
             annotation.call = this.finishCall(leftParen, annotation, false);
         }
@@ -927,7 +1008,7 @@ class Parser {
         }
         const questionMarkToken = this.advance();
         //consume newlines or comments
-        while (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
+        while (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
             this.advance();
         }
         let consequent;
@@ -936,12 +1017,12 @@ class Parser {
         }
         catch (_a) { }
         //consume newlines or comments
-        while (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
+        while (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
             this.advance();
         }
-        const colonToken = this.tryConsumeToken(lexer_1.TokenKind.Colon);
+        const colonToken = this.tryConsumeToken(TokenKind_1.TokenKind.Colon);
         //consume newlines
-        while (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
+        while (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
             this.advance();
         }
         let alternate;
@@ -959,7 +1040,7 @@ class Parser {
     }
     regexLiteralExpression() {
         this.warnIfNotBrighterScriptMode('regular expression literal');
-        return new _1.RegexLiteralExpression({
+        return new Expression_1.RegexLiteralExpression({
             regexLiteral: this.advance()
         });
     }
@@ -968,23 +1049,23 @@ class Parser {
         //get the tag name
         let tagName;
         if (isTagged) {
-            tagName = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+            tagName = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
             // force it into an identifier so the AST makes some sense
-            tagName.kind = lexer_1.TokenKind.Identifier;
+            tagName.kind = TokenKind_1.TokenKind.Identifier;
         }
         let quasis = [];
         let expressions = [];
         let openingBacktick = this.peek();
         this.advance();
         let currentQuasiExpressionParts = [];
-        while (!this.isAtEnd() && !this.check(lexer_1.TokenKind.BackTick)) {
+        while (!this.isAtEnd() && !this.check(TokenKind_1.TokenKind.BackTick)) {
             let next = this.peek();
-            if (next.kind === lexer_1.TokenKind.TemplateStringQuasi) {
+            if (next.kind === TokenKind_1.TokenKind.TemplateStringQuasi) {
                 //a quasi can actually be made up of multiple quasis when it includes char literals
                 currentQuasiExpressionParts.push(new Expression_1.LiteralExpression(next));
                 this.advance();
             }
-            else if (next.kind === lexer_1.TokenKind.EscapedCharCodeLiteral) {
+            else if (next.kind === TokenKind_1.TokenKind.EscapedCharCodeLiteral) {
                 currentQuasiExpressionParts.push(new Expression_1.EscapedCharCodeLiteralExpression(next));
                 this.advance();
             }
@@ -992,12 +1073,12 @@ class Parser {
                 //finish up the current quasi
                 quasis.push(new Expression_1.TemplateStringQuasiExpression(currentQuasiExpressionParts));
                 currentQuasiExpressionParts = [];
-                if (next.kind === lexer_1.TokenKind.TemplateStringExpressionBegin) {
+                if (next.kind === TokenKind_1.TokenKind.TemplateStringExpressionBegin) {
                     this.advance();
                 }
                 //now keep this expression
                 expressions.push(this.expression());
-                if (!this.isAtEnd() && this.check(lexer_1.TokenKind.TemplateStringExpressionEnd)) {
+                if (!this.isAtEnd() && this.check(TokenKind_1.TokenKind.TemplateStringExpressionEnd)) {
                     //TODO is it an error if this is not present?
                     this.advance();
                 }
@@ -1029,12 +1110,12 @@ class Parser {
         const statement = new Statement_1.TryCatchStatement(tryToken);
         //ensure statement separator
         this.consumeStatementSeparators();
-        statement.tryBranch = this.block(lexer_1.TokenKind.Catch, lexer_1.TokenKind.EndTry);
+        statement.tryBranch = this.block(TokenKind_1.TokenKind.Catch, TokenKind_1.TokenKind.EndTry);
         const peek = this.peek();
-        if (peek.kind !== lexer_1.TokenKind.Catch) {
+        if (peek.kind !== TokenKind_1.TokenKind.Catch) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedCatchBlockInTryCatch()), { range: this.peek().range }));
             //gracefully handle end-try
-            if (peek.kind === lexer_1.TokenKind.EndTry) {
+            if (peek.kind === TokenKind_1.TokenKind.EndTry) {
                 statement.endTryToken = this.advance();
             }
             return statement;
@@ -1042,16 +1123,16 @@ class Parser {
         else {
             statement.catchToken = this.advance();
         }
-        const exceptionVarToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingExceptionVarToFollowCatch(), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+        const exceptionVarToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingExceptionVarToFollowCatch(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
         if (exceptionVarToken) {
             // force it into an identifier so the AST makes some sense
-            exceptionVarToken.kind = lexer_1.TokenKind.Identifier;
+            exceptionVarToken.kind = TokenKind_1.TokenKind.Identifier;
             statement.exceptionVariable = exceptionVarToken;
         }
         //ensure statement sepatator
         this.consumeStatementSeparators();
-        statement.catchBranch = this.block(lexer_1.TokenKind.EndTry);
-        if (this.peek().kind !== lexer_1.TokenKind.EndTry) {
+        statement.catchBranch = this.block(TokenKind_1.TokenKind.EndTry);
+        if (this.peek().kind !== TokenKind_1.TokenKind.EndTry) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndTryToTerminateTryCatch()), { range: this.peek().range }));
         }
         else {
@@ -1062,7 +1143,7 @@ class Parser {
     throwStatement() {
         const throwToken = this.advance();
         let expression;
-        if (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon)) {
+        if (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon)) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExceptionExpressionAfterThrowKeyword()), { range: throwToken.range }));
         }
         else {
@@ -1072,19 +1153,19 @@ class Parser {
     }
     dimStatement() {
         const dim = this.advance();
-        let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('dim'), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+        let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('dim'), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
         // force to an identifier so the AST makes some sense
         if (identifier) {
-            identifier.kind = lexer_1.TokenKind.Identifier;
+            identifier.kind = TokenKind_1.TokenKind.Identifier;
         }
-        let leftSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingLeftSquareBracketAfterDimIdentifier(), lexer_1.TokenKind.LeftSquareBracket);
+        let leftSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingLeftSquareBracketAfterDimIdentifier(), TokenKind_1.TokenKind.LeftSquareBracket);
         let expressions = [];
         let expression;
         do {
             try {
                 expression = this.expression();
                 expressions.push(expression);
-                if (this.check(lexer_1.TokenKind.Comma)) {
+                if (this.check(TokenKind_1.TokenKind.Comma)) {
                     this.advance();
                 }
                 else {
@@ -1098,15 +1179,15 @@ class Parser {
         if (expressions.length === 0) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExpressionsInDimStatement()), { range: this.peek().range }));
         }
-        let rightSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingRightSquareBracketAfterDimIdentifier(), lexer_1.TokenKind.RightSquareBracket);
+        let rightSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingRightSquareBracketAfterDimIdentifier(), TokenKind_1.TokenKind.RightSquareBracket);
         return new Statement_1.DimStatement(dim, identifier, leftSquareBracket, expressions, rightSquareBracket);
     }
     ifStatement() {
         // colon before `if` is usually not allowed, unless it's after `then`
         if (this.current > 0) {
             const prev = this.previous();
-            if (prev.kind === lexer_1.TokenKind.Colon) {
-                if (this.current > 1 && this.tokens[this.current - 2].kind !== lexer_1.TokenKind.Then) {
+            if (prev.kind === TokenKind_1.TokenKind.Colon) {
+                if (this.current > 1 && this.tokens[this.current - 2].kind !== TokenKind_1.TokenKind.Then) {
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedColonBeforeIfStatement()), { range: prev.range }));
                 }
             }
@@ -1120,14 +1201,14 @@ class Parser {
         let endIfToken;
         let elseToken;
         //optional `then`
-        if (this.check(lexer_1.TokenKind.Then)) {
+        if (this.check(TokenKind_1.TokenKind.Then)) {
             thenToken = this.advance();
         }
         //is it inline or multi-line if?
-        const isInlineIfThen = !this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Comment);
+        const isInlineIfThen = !this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment);
         if (isInlineIfThen) {
             /*** PARSE INLINE IF STATEMENT ***/
-            thenBranch = this.inlineConditionalBranch(lexer_1.TokenKind.Else, lexer_1.TokenKind.EndIf);
+            thenBranch = this.inlineConditionalBranch(TokenKind_1.TokenKind.Else, TokenKind_1.TokenKind.EndIf);
             if (!thenBranch) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatementToFollowConditionalCondition(ifToken.text)), { range: this.peek().range }));
                 throw this.lastDiagnosticAsError();
@@ -1136,9 +1217,9 @@ class Parser {
                 this.ensureInline(thenBranch.statements);
             }
             //else branch
-            if (this.check(lexer_1.TokenKind.Else)) {
+            if (this.check(TokenKind_1.TokenKind.Else)) {
                 elseToken = this.advance();
-                if (this.check(lexer_1.TokenKind.If)) {
+                if (this.check(TokenKind_1.TokenKind.If)) {
                     // recurse-read `else if`
                     elseBranch = this.ifStatement();
                     //no multi-line if chained with an inline if
@@ -1146,13 +1227,13 @@ class Parser {
                         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement()), { range: elseBranch.range }));
                     }
                 }
-                else if (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon)) {
+                else if (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon)) {
                     //expecting inline else branch
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement()), { range: this.peek().range }));
                     throw this.lastDiagnosticAsError();
                 }
                 else {
-                    elseBranch = this.inlineConditionalBranch(lexer_1.TokenKind.Else, lexer_1.TokenKind.EndIf);
+                    elseBranch = this.inlineConditionalBranch(TokenKind_1.TokenKind.Else, TokenKind_1.TokenKind.EndIf);
                     if (elseBranch) {
                         this.ensureInline(elseBranch.statements);
                     }
@@ -1166,9 +1247,9 @@ class Parser {
             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()) {
+                if (peek.kind !== TokenKind_1.TokenKind.Newline && peek.kind !== TokenKind_1.TokenKind.Comment && !this.isAtEnd()) {
                     //ignore last error if it was about a colon
-                    if (this.previous().kind === lexer_1.TokenKind.Colon) {
+                    if (this.previous().kind === TokenKind_1.TokenKind.Colon) {
                         this.diagnostics.pop();
                         this.current--;
                     }
@@ -1183,9 +1264,9 @@ class Parser {
             //ensure newline/colon before next keyword
             this.ensureNewLineOrColon();
             //else branch
-            if (this.check(lexer_1.TokenKind.Else)) {
+            if (this.check(TokenKind_1.TokenKind.Else)) {
                 elseToken = this.advance();
-                if (this.check(lexer_1.TokenKind.If)) {
+                if (this.check(TokenKind_1.TokenKind.If)) {
                     // recurse-read `else if`
                     elseBranch = this.ifStatement();
                 }
@@ -1196,7 +1277,7 @@ class Parser {
                 }
             }
             if (!(0, reflection_1.isIfStatement)(elseBranch)) {
-                if (this.check(lexer_1.TokenKind.EndIf)) {
+                if (this.check(TokenKind_1.TokenKind.EndIf)) {
                     endIfToken = this.advance();
                 }
                 else {
@@ -1219,7 +1300,7 @@ class Parser {
         let diagnosticsLengthBeforeBlock = this.diagnostics.length;
         // we're parsing a multi-line ("block") form of the BrightScript if/then and must find
         // a trailing "end if" or "else if"
-        let branch = this.block(lexer_1.TokenKind.EndIf, lexer_1.TokenKind.Else);
+        let branch = this.block(TokenKind_1.TokenKind.EndIf, TokenKind_1.TokenKind.Else);
         if (!branch) {
             //throw out any new diagnostics created as a result of a `then` block parse failure.
             //the block() function will discard the current line, so any discarded diagnostics will
@@ -1233,7 +1314,7 @@ class Parser {
     }
     ensureNewLineOrColon(silent = false) {
         const prev = this.previous().kind;
-        if (prev !== lexer_1.TokenKind.Newline && prev !== lexer_1.TokenKind.Colon) {
+        if (prev !== TokenKind_1.TokenKind.Newline && prev !== TokenKind_1.TokenKind.Colon) {
             if (!silent) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedNewlineOrColon()), { range: this.peek().range }));
             }
@@ -1262,12 +1343,12 @@ class Parser {
         const startingRange = statement.range;
         //look for colon statement separator
         let foundColon = false;
-        while (this.match(lexer_1.TokenKind.Colon)) {
+        while (this.match(TokenKind_1.TokenKind.Colon)) {
             foundColon = true;
         }
         //if a colon was found, add the next statement or err if unexpected
         if (foundColon) {
-            if (!this.checkAny(lexer_1.TokenKind.Newline, ...additionalTerminators)) {
+            if (!this.checkAny(TokenKind_1.TokenKind.Newline, ...additionalTerminators)) {
                 //if not an ending keyword, add next statement
                 let extra = this.inlineConditionalBranch(...additionalTerminators);
                 if (!extra) {
@@ -1285,9 +1366,9 @@ class Parser {
     }
     expressionStatement(expr) {
         let expressionStart = this.peek();
-        if (this.checkAny(lexer_1.TokenKind.PlusPlus, lexer_1.TokenKind.MinusMinus)) {
+        if (this.checkAny(TokenKind_1.TokenKind.PlusPlus, TokenKind_1.TokenKind.MinusMinus)) {
             let operator = this.advance();
-            if (this.checkAny(lexer_1.TokenKind.PlusPlus, lexer_1.TokenKind.MinusMinus)) {
+            if (this.checkAny(TokenKind_1.TokenKind.PlusPlus, TokenKind_1.TokenKind.MinusMinus)) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.consecutiveIncrementDecrementOperatorsAreNotAllowed()), { range: this.peek().range }));
                 throw this.lastDiagnosticAsError();
             }
@@ -1295,7 +1376,9 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.incrementDecrementOperatorsAreNotAllowedAsResultOfFunctionCall()), { range: expressionStart.range }));
                 throw this.lastDiagnosticAsError();
             }
-            return new Statement_1.IncrementStatement(expr, operator);
+            const result = new Statement_1.IncrementStatement(expr, operator);
+            this._references.expressions.add(result);
+            return result;
         }
         if ((0, reflection_1.isCallExpression)(expr) || (0, reflection_1.isCallfuncExpression)(expr)) {
             return new Statement_1.ExpressionStatement(expr);
@@ -1312,18 +1395,18 @@ 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) && !((0, reflection_1.isCallExpression)(expr))) {
+        if (this.checkAny(...TokenKind_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 ((0, reflection_1.isIndexedGetExpression)(left)) {
-                return new Statement_1.IndexedSetStatement(left.obj, left.index, operator.kind === lexer_1.TokenKind.Equal
+                return new Statement_1.IndexedSetStatement(left.obj, left.index, operator.kind === TokenKind_1.TokenKind.Equal
                     ? right
                     : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare);
             }
             else if ((0, reflection_1.isDottedGetExpression)(left)) {
-                const dottedSetStmt = 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 === TokenKind_1.TokenKind.Equal
                     ? right
                     : new Expression_1.BinaryExpression(left, operator, right));
                 this._references.dottedSetStatements.push(dottedSetStmt);
@@ -1336,13 +1419,13 @@ class Parser {
         let printKeyword = this.advance();
         let values = [];
         while (!this.checkEndOfStatement()) {
-            if (this.check(lexer_1.TokenKind.Semicolon)) {
+            if (this.check(TokenKind_1.TokenKind.Semicolon)) {
                 values.push(this.advance());
             }
-            else if (this.check(lexer_1.TokenKind.Comma)) {
+            else if (this.check(TokenKind_1.TokenKind.Comma)) {
                 values.push(this.advance());
             }
-            else if (this.check(lexer_1.TokenKind.Else)) {
+            else if (this.check(TokenKind_1.TokenKind.Else)) {
                 break; // inline branch
             }
             else {
@@ -1355,7 +1438,7 @@ class Parser {
             values.push(emptyStringLiteral);
         }
         let last = values[values.length - 1];
-        if ((0, lexer_1.isToken)(last)) {
+        if ((0, Token_1.isToken)(last)) {
             // TODO: error, expected value
         }
         return new Statement_1.PrintStatement({ print: printKeyword }, values);
@@ -1369,7 +1452,7 @@ class Parser {
         if (this.checkEndOfStatement()) {
             return new Statement_1.ReturnStatement(tokens);
         }
-        let toReturn = this.check(lexer_1.TokenKind.Else) ? undefined : this.expression();
+        let toReturn = this.check(TokenKind_1.TokenKind.Else) ? undefined : this.expression();
         return new Statement_1.ReturnStatement(tokens, toReturn);
     }
     /**
@@ -1382,7 +1465,7 @@ class Parser {
             colon: this.advance()
         };
         //label must be alone on its line, this is probably not a label
-        if (!this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
+        if (!this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
             //rewind and cancel
             this.current -= 2;
             throw new CancelStatementError();
@@ -1398,7 +1481,7 @@ class Parser {
     gotoStatement() {
         let tokens = {
             goto: this.advance(),
-            label: this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLabelIdentifierAfterGotoKeyword(), lexer_1.TokenKind.Identifier)
+            label: this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLabelIdentifierAfterGotoKeyword(), TokenKind_1.TokenKind.Identifier)
         };
         return new Statement_1.GotoStatement(tokens);
     }
@@ -1429,7 +1512,7 @@ class Parser {
         this.consumeStatementSeparators(true);
         let startingToken = this.peek();
         const statements = [];
-        while (!this.isAtEnd() && !this.checkAny(lexer_1.TokenKind.EndSub, lexer_1.TokenKind.EndFunction, ...terminators)) {
+        while (!this.isAtEnd() && !this.checkAny(TokenKind_1.TokenKind.EndSub, TokenKind_1.TokenKind.EndFunction, ...terminators)) {
             //grab the location of the current token
             let loopCurrent = this.current;
             let dec = this.declaration();
@@ -1445,7 +1528,7 @@ class Parser {
                 //something went wrong. reset to the top of the loop
                 this.current = loopCurrent;
                 //scrap the entire line (hopefully whatever failed has added a diagnostic)
-                this.consumeUntil(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Eof);
+                this.consumeUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
                 //trash the next token. this prevents an infinite loop. not exactly sure why we need this,
                 //but there's already an error in the file being parsed, so just leave this line here
                 this.advance();
@@ -1462,8 +1545,8 @@ class Parser {
             //if so, we need to restore the statement separator
             let prev = this.previous().kind;
             let peek = this.peek().kind;
-            if ((peek === lexer_1.TokenKind.EndSub || peek === lexer_1.TokenKind.EndFunction) &&
-                (prev === lexer_1.TokenKind.Newline || prev === lexer_1.TokenKind.Colon)) {
+            if ((peek === TokenKind_1.TokenKind.EndSub || peek === TokenKind_1.TokenKind.EndFunction) &&
+                (prev === TokenKind_1.TokenKind.Newline || prev === TokenKind_1.TokenKind.Colon)) {
                 this.current--;
             }
         }
@@ -1495,13 +1578,15 @@ class Parser {
         this.pendingAnnotations = parentAnnotations;
     }
     expression() {
-        return this.anonymousFunction();
+        const expression = this.anonymousFunction();
+        this._references.expressions.add(expression);
+        return expression;
     }
     anonymousFunction() {
-        if (this.checkAny(lexer_1.TokenKind.Sub, lexer_1.TokenKind.Function)) {
+        if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
             const func = this.functionDeclaration(true);
             //if there's an open paren after this, this is an IIFE
-            if (this.check(lexer_1.TokenKind.LeftParen)) {
+            if (this.check(TokenKind_1.TokenKind.LeftParen)) {
                 return this.finishCall(this.advance(), func);
             }
             else {
@@ -1509,10 +1594,10 @@ class Parser {
             }
         }
         let expr = this.boolean();
-        if (this.check(lexer_1.TokenKind.Question)) {
+        if (this.check(TokenKind_1.TokenKind.Question)) {
             return this.ternaryExpression(expr);
         }
-        else if (this.check(lexer_1.TokenKind.QuestionQuestion)) {
+        else if (this.check(TokenKind_1.TokenKind.QuestionQuestion)) {
             return this.nullCoalescingExpression(expr);
         }
         else {
@@ -1521,7 +1606,7 @@ class Parser {
     }
     boolean() {
         let expr = this.relational();
-        while (this.matchAny(lexer_1.TokenKind.And, lexer_1.TokenKind.Or)) {
+        while (this.matchAny(TokenKind_1.TokenKind.And, TokenKind_1.TokenKind.Or)) {
             let operator = this.previous();
             let right = this.relational();
             expr = new Expression_1.BinaryExpression(expr, operator, right);
@@ -1530,7 +1615,7 @@ class Parser {
     }
     relational() {
         let expr = this.additive();
-        while (this.matchAny(lexer_1.TokenKind.Equal, lexer_1.TokenKind.LessGreater, lexer_1.TokenKind.Greater, lexer_1.TokenKind.GreaterEqual, lexer_1.TokenKind.Less, lexer_1.TokenKind.LessEqual)) {
+        while (this.matchAny(TokenKind_1.TokenKind.Equal, TokenKind_1.TokenKind.LessGreater, TokenKind_1.TokenKind.Greater, TokenKind_1.TokenKind.GreaterEqual, TokenKind_1.TokenKind.Less, TokenKind_1.TokenKind.LessEqual)) {
             let operator = this.previous();
             let right = this.additive();
             expr = new Expression_1.BinaryExpression(expr, operator, right);
@@ -1540,7 +1625,7 @@ class Parser {
     // TODO: bitshift
     additive() {
         let expr = this.multiplicative();
-        while (this.matchAny(lexer_1.TokenKind.Plus, lexer_1.TokenKind.Minus)) {
+        while (this.matchAny(TokenKind_1.TokenKind.Plus, TokenKind_1.TokenKind.Minus)) {
             let operator = this.previous();
             let right = this.multiplicative();
             expr = new Expression_1.BinaryExpression(expr, operator, right);
@@ -1549,7 +1634,7 @@ class Parser {
     }
     multiplicative() {
         let expr = this.exponential();
-        while (this.matchAny(lexer_1.TokenKind.Forwardslash, lexer_1.TokenKind.Backslash, lexer_1.TokenKind.Star, lexer_1.TokenKind.Mod, lexer_1.TokenKind.LeftShift, lexer_1.TokenKind.RightShift)) {
+        while (this.matchAny(TokenKind_1.TokenKind.Forwardslash, TokenKind_1.TokenKind.Backslash, TokenKind_1.TokenKind.Star, TokenKind_1.TokenKind.Mod, TokenKind_1.TokenKind.LeftShift, TokenKind_1.TokenKind.RightShift)) {
             let operator = this.previous();
             let right = this.exponential();
             expr = new Expression_1.BinaryExpression(expr, operator, right);
@@ -1558,7 +1643,7 @@ class Parser {
     }
     exponential() {
         let expr = this.prefixUnary();
-        while (this.match(lexer_1.TokenKind.Caret)) {
+        while (this.match(TokenKind_1.TokenKind.Caret)) {
             let operator = this.previous();
             let right = this.prefixUnary();
             expr = new Expression_1.BinaryExpression(expr, operator, right);
@@ -1567,7 +1652,7 @@ class Parser {
     }
     prefixUnary() {
         const nextKind = this.peek().kind;
-        if (nextKind === lexer_1.TokenKind.Not || nextKind === lexer_1.TokenKind.Minus) {
+        if (nextKind === TokenKind_1.TokenKind.Not || nextKind === TokenKind_1.TokenKind.Minus) {
             this.current++; //advance
             let operator = this.previous();
             let right = this.prefixUnary();
@@ -1577,17 +1662,17 @@ class Parser {
     }
     indexedGet(expr) {
         let openingSquare = this.previous();
-        while (this.match(lexer_1.TokenKind.Newline)) { }
+        while (this.match(TokenKind_1.TokenKind.Newline)) { }
         let index = this.expression();
-        while (this.match(lexer_1.TokenKind.Newline)) { }
-        let closingSquare = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightSquareBraceAfterArrayOrObjectIndex(), lexer_1.TokenKind.RightSquareBracket);
+        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        let closingSquare = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightSquareBraceAfterArrayOrObjectIndex(), TokenKind_1.TokenKind.RightSquareBracket);
         return new Expression_1.IndexedGetExpression(expr, index, openingSquare, closingSquare);
     }
     newExpression() {
         this.warnIfNotBrighterScriptMode(`using 'new' keyword to construct a class`);
         let newToken = this.advance();
         let nameExpr = this.getNamespacedVariableNameExpression();
-        let leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), lexer_1.TokenKind.LeftParen);
+        let leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_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();
@@ -1601,46 +1686,52 @@ class Parser {
     callfunc(callee) {
         this.warnIfNotBrighterScriptMode('callfunc operator');
         let operator = this.previous();
-        let methodName = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+        let methodName = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         // force it into an identifier so the AST makes some sense
-        methodName.kind = lexer_1.TokenKind.Identifier;
-        let openParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOpenParenToFollowCallfuncIdentifier(), lexer_1.TokenKind.LeftParen);
+        methodName.kind = TokenKind_1.TokenKind.Identifier;
+        let openParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOpenParenToFollowCallfuncIdentifier(), TokenKind_1.TokenKind.LeftParen);
         let call = this.finishCall(openParen, callee, false);
         return new Expression_1.CallfuncExpression(callee, operator, methodName, openParen, call.args, call.closingParen);
     }
     call() {
-        if (this.check(lexer_1.TokenKind.New) && this.checkAnyNext(lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+        if (this.check(TokenKind_1.TokenKind.New) && this.checkAnyNext(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
             return this.newExpression();
         }
         let expr = this.primary();
+        //an expression to keep for _references
+        let referenceCallExpression;
         while (true) {
-            if (this.match(lexer_1.TokenKind.LeftParen)) {
+            if (this.match(TokenKind_1.TokenKind.LeftParen)) {
                 expr = this.finishCall(this.previous(), expr);
+                //store this call expression in references
+                referenceCallExpression = expr;
             }
-            else if (this.match(lexer_1.TokenKind.LeftSquareBracket)) {
+            else if (this.match(TokenKind_1.TokenKind.LeftSquareBracket)) {
                 expr = this.indexedGet(expr);
             }
-            else if (this.match(lexer_1.TokenKind.Callfunc)) {
+            else if (this.match(TokenKind_1.TokenKind.Callfunc)) {
                 expr = this.callfunc(expr);
+                //store this callfunc expression in references
+                referenceCallExpression = expr;
             }
-            else if (this.match(lexer_1.TokenKind.Dot)) {
-                if (this.match(lexer_1.TokenKind.LeftSquareBracket)) {
+            else if (this.match(TokenKind_1.TokenKind.Dot)) {
+                if (this.match(TokenKind_1.TokenKind.LeftSquareBracket)) {
                     expr = this.indexedGet(expr);
                 }
                 else {
                     let dot = this.previous();
-                    let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedPropertyNameAfterPeriod(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+                    let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedPropertyNameAfterPeriod(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
                     // force it into an identifier so the AST makes some sense
-                    name.kind = lexer_1.TokenKind.Identifier;
+                    name.kind = TokenKind_1.TokenKind.Identifier;
                     expr = new Expression_1.DottedGetExpression(expr, name, dot);
                     this.addPropertyHints(name);
                 }
             }
-            else if (this.check(lexer_1.TokenKind.At)) {
+            else if (this.check(TokenKind_1.TokenKind.At)) {
                 let dot = this.advance();
-                let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedAttributeNameAfterAtSymbol(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+                let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedAttributeNameAfterAtSymbol(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
                 // force it into an identifier so the AST makes some sense
-                name.kind = lexer_1.TokenKind.Identifier;
+                name.kind = TokenKind_1.TokenKind.Identifier;
                 expr = new Expression_1.XmlAttributeGetExpression(expr, name, dot);
                 //only allow a single `@` expression
                 break;
@@ -1649,24 +1740,28 @@ class Parser {
                 break;
             }
         }
+        //if we found a callExpression, add it to `expressions` in references
+        if (referenceCallExpression) {
+            this._references.expressions.add(referenceCallExpression);
+        }
         return expr;
     }
     finishCall(openingParen, callee, addToCallExpressionList = true) {
         let args = [];
-        while (this.match(lexer_1.TokenKind.Newline)) {
+        while (this.match(TokenKind_1.TokenKind.Newline)) {
         }
-        if (!this.check(lexer_1.TokenKind.RightParen)) {
+        if (!this.check(TokenKind_1.TokenKind.RightParen)) {
             do {
-                while (this.match(lexer_1.TokenKind.Newline)) { }
+                while (this.match(TokenKind_1.TokenKind.Newline)) { }
                 if (args.length >= Expression_1.CallExpression.MaximumArguments) {
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableArguments(args.length, Expression_1.CallExpression.MaximumArguments)), { range: this.peek().range }));
                     throw this.lastDiagnosticAsError();
                 }
                 args.push(this.expression());
-            } while (this.match(lexer_1.TokenKind.Comma));
+            } while (this.match(TokenKind_1.TokenKind.Comma));
         }
-        while (this.match(lexer_1.TokenKind.Newline)) { }
-        const closingParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), lexer_1.TokenKind.RightParen);
+        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        const closingParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), TokenKind_1.TokenKind.RightParen);
         if ((0, reflection_1.isVariableExpression)(callee)) {
             callee.isCalled = true;
         }
@@ -1683,15 +1778,15 @@ class Parser {
      */
     typeToken() {
         let typeToken;
-        if (this.checkAny(...lexer_1.DeclarableTypes)) {
+        if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
             // Token is a built in type
             typeToken = this.advance();
         }
         else if (this.options.mode === ParseMode.BrighterScript) {
             try {
-                // see if we can get a namespaced identifer
+                // see if we can get a namespaced identifier
                 const qualifiedType = this.getNamespacedVariableNameExpression();
-                typeToken = (0, creators_1.createToken)(lexer_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
+                typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
             }
             catch (_a) {
                 //could not get an identifier - just get whatever's next
@@ -1702,57 +1797,68 @@ class Parser {
             // just get whatever's next
             typeToken = this.advance();
         }
+        if (typeToken && this.options.mode === ParseMode.BrighterScript) {
+            // Check if it is an array - that is, if it has `[]` after the type
+            // eg. `string[]` or `SomeKlass[]`
+            if (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
+                this.advance();
+                if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
+                    const rightBracket = this.advance();
+                    typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, typeToken.text + '[]', util_1.util.getRange(typeToken, rightBracket));
+                }
+            }
+        }
         return typeToken;
     }
     primary() {
         switch (true) {
-            case this.matchAny(lexer_1.TokenKind.False, lexer_1.TokenKind.True, lexer_1.TokenKind.Invalid, lexer_1.TokenKind.IntegerLiteral, lexer_1.TokenKind.LongIntegerLiteral, lexer_1.TokenKind.FloatLiteral, lexer_1.TokenKind.DoubleLiteral, lexer_1.TokenKind.StringLiteral):
+            case this.matchAny(TokenKind_1.TokenKind.False, TokenKind_1.TokenKind.True, TokenKind_1.TokenKind.Invalid, TokenKind_1.TokenKind.IntegerLiteral, TokenKind_1.TokenKind.LongIntegerLiteral, TokenKind_1.TokenKind.FloatLiteral, TokenKind_1.TokenKind.DoubleLiteral, TokenKind_1.TokenKind.StringLiteral):
                 return new Expression_1.LiteralExpression(this.previous());
             //capture source literals (LINE_NUM if brightscript, or a bunch of them if brighterscript)
-            case this.matchAny(lexer_1.TokenKind.LineNumLiteral, ...(this.options.mode === ParseMode.BrightScript ? [] : lexer_1.BrighterScriptSourceLiterals)):
+            case this.matchAny(TokenKind_1.TokenKind.LineNumLiteral, ...(this.options.mode === ParseMode.BrightScript ? [] : TokenKind_1.BrighterScriptSourceLiterals)):
                 return new Expression_1.SourceLiteralExpression(this.previous());
             //template string
-            case this.check(lexer_1.TokenKind.BackTick):
+            case this.check(TokenKind_1.TokenKind.BackTick):
                 return this.templateString(false);
             //tagged template string (currently we do not support spaces between the identifier and the backtick)
-            case this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedLocalIdentifiers) && this.checkNext(lexer_1.TokenKind.BackTick):
+            case this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedLocalIdentifiers) && this.checkNext(TokenKind_1.TokenKind.BackTick):
                 return this.templateString(true);
-            case this.matchAny(lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers):
+            case this.matchAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers):
                 return new Expression_1.VariableExpression(this.previous(), this.currentNamespaceName);
-            case this.match(lexer_1.TokenKind.LeftParen):
+            case this.match(TokenKind_1.TokenKind.LeftParen):
                 let left = this.previous();
                 let expr = this.expression();
-                let right = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftParenAfterExpression(), lexer_1.TokenKind.RightParen);
+                let right = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftParenAfterExpression(), TokenKind_1.TokenKind.RightParen);
                 return new Expression_1.GroupingExpression({ left: left, right: right }, expr);
-            case this.match(lexer_1.TokenKind.LeftSquareBracket):
+            case this.match(TokenKind_1.TokenKind.LeftSquareBracket):
                 let elements = [];
                 let openingSquare = this.previous();
                 //add any comment found right after the opening square
-                if (this.check(lexer_1.TokenKind.Comment)) {
+                if (this.check(TokenKind_1.TokenKind.Comment)) {
                     elements.push(new Statement_1.CommentStatement([this.advance()]));
                 }
-                while (this.match(lexer_1.TokenKind.Newline)) {
+                while (this.match(TokenKind_1.TokenKind.Newline)) {
                 }
-                if (!this.match(lexer_1.TokenKind.RightSquareBracket)) {
+                if (!this.match(TokenKind_1.TokenKind.RightSquareBracket)) {
                     elements.push(this.expression());
-                    while (this.matchAny(lexer_1.TokenKind.Comma, lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
-                        if (this.checkPrevious(lexer_1.TokenKind.Comment) || this.check(lexer_1.TokenKind.Comment)) {
-                            let comment = this.check(lexer_1.TokenKind.Comment) ? this.advance() : this.previous();
+                    while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
+                        if (this.checkPrevious(TokenKind_1.TokenKind.Comment) || this.check(TokenKind_1.TokenKind.Comment)) {
+                            let comment = this.check(TokenKind_1.TokenKind.Comment) ? this.advance() : this.previous();
                             elements.push(new Statement_1.CommentStatement([comment]));
                         }
-                        while (this.match(lexer_1.TokenKind.Newline)) {
+                        while (this.match(TokenKind_1.TokenKind.Newline)) {
                         }
-                        if (this.check(lexer_1.TokenKind.RightSquareBracket)) {
+                        if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
                             break;
                         }
                         elements.push(this.expression());
                     }
-                    this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftSquareBraceAfterArrayLiteral(), lexer_1.TokenKind.RightSquareBracket);
+                    this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftSquareBraceAfterArrayLiteral(), TokenKind_1.TokenKind.RightSquareBracket);
                 }
                 let closingSquare = this.previous();
                 //this.consume("Expected newline or ':' after array literal", TokenKind.Newline, TokenKind.Colon, TokenKind.Eof);
                 return new Expression_1.ArrayLiteralExpression(elements, openingSquare, closingSquare);
-            case this.match(lexer_1.TokenKind.LeftCurlyBrace):
+            case this.match(TokenKind_1.TokenKind.LeftCurlyBrace):
                 let openingBrace = this.previous();
                 let members = [];
                 let key = () => {
@@ -1761,25 +1867,25 @@ class Parser {
                         keyToken: null,
                         range: null
                     };
-                    if (this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties)) {
+                    if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
                         result.keyToken = this.advance();
                     }
-                    else if (this.check(lexer_1.TokenKind.StringLiteral)) {
+                    else if (this.check(TokenKind_1.TokenKind.StringLiteral)) {
                         result.keyToken = this.advance();
                     }
                     else {
                         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedAAKey()), { range: this.peek().range }));
                         throw this.lastDiagnosticAsError();
                     }
-                    result.colonToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), lexer_1.TokenKind.Colon);
+                    result.colonToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), TokenKind_1.TokenKind.Colon);
                     result.range = util_1.util.getRange(result.keyToken, result.colonToken);
                     return result;
                 };
-                while (this.match(lexer_1.TokenKind.Newline)) {
+                while (this.match(TokenKind_1.TokenKind.Newline)) {
                 }
-                if (!this.match(lexer_1.TokenKind.RightCurlyBrace)) {
+                if (!this.match(TokenKind_1.TokenKind.RightCurlyBrace)) {
                     let lastAAMember;
-                    if (this.check(lexer_1.TokenKind.Comment)) {
+                    if (this.check(TokenKind_1.TokenKind.Comment)) {
                         lastAAMember = null;
                         members.push(new Statement_1.CommentStatement([this.advance()]));
                     }
@@ -1789,26 +1895,26 @@ class Parser {
                         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)) {
+                    while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
                         // collect comma at end of expression
-                        if (lastAAMember && this.checkPrevious(lexer_1.TokenKind.Comma)) {
+                        if (lastAAMember && this.checkPrevious(TokenKind_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();
+                        if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
+                            let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
                             members.push(new Statement_1.CommentStatement([token]));
                         }
                         else {
                             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();
+                            if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
+                                let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
                                 lastAAMember = null;
                                 members.push(new Statement_1.CommentStatement([token]));
                                 continue;
                             }
-                            if (this.check(lexer_1.TokenKind.RightCurlyBrace)) {
+                            if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
                                 break;
                             }
                             let k = key();
@@ -1817,23 +1923,23 @@ class Parser {
                             members.push(lastAAMember);
                         }
                     }
-                    this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), lexer_1.TokenKind.RightCurlyBrace);
+                    this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), TokenKind_1.TokenKind.RightCurlyBrace);
                 }
                 let closingBrace = this.previous();
                 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):
+            case this.matchAny(TokenKind_1.TokenKind.Pos, TokenKind_1.TokenKind.Tab):
                 let token = Object.assign(this.previous(), {
-                    kind: lexer_1.TokenKind.Identifier
+                    kind: TokenKind_1.TokenKind.Identifier
                 });
                 return new Expression_1.VariableExpression(token, this.currentNamespaceName);
-            case this.checkAny(lexer_1.TokenKind.Function, lexer_1.TokenKind.Sub):
+            case this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub):
                 return this.anonymousFunction();
-            case this.check(lexer_1.TokenKind.RegexLiteral):
+            case this.check(TokenKind_1.TokenKind.RegexLiteral):
                 return this.regexLiteralExpression();
-            case this.check(lexer_1.TokenKind.Comment):
+            case this.check(TokenKind_1.TokenKind.Comment):
                 return new Statement_1.CommentStatement([this.advance()]);
             default:
                 //if we found an expected terminator, don't throw a diagnostic...just return undefined
@@ -1903,12 +2009,12 @@ class Parser {
     }
     consumeStatementSeparators(optional = false) {
         //a comment or EOF mark the end of the statement
-        if (this.isAtEnd() || this.check(lexer_1.TokenKind.Comment)) {
+        if (this.isAtEnd() || this.check(TokenKind_1.TokenKind.Comment)) {
             return true;
         }
         let consumed = false;
         //consume any newlines and colons
-        while (this.matchAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon)) {
+        while (this.matchAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon)) {
             consumed = true;
         }
         if (!optional && !consumed) {
@@ -1924,7 +2030,7 @@ class Parser {
     }
     checkEndOfStatement() {
         const nextKind = this.peek().kind;
-        return [lexer_1.TokenKind.Colon, lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment, lexer_1.TokenKind.Eof].includes(nextKind);
+        return [TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Eof].includes(nextKind);
     }
     checkPrevious(tokenKind) {
         var _a;
@@ -1932,14 +2038,14 @@ class Parser {
     }
     check(tokenKind) {
         const nextKind = this.peek().kind;
-        if (nextKind === lexer_1.TokenKind.Eof) {
+        if (nextKind === TokenKind_1.TokenKind.Eof) {
             return false;
         }
         return nextKind === tokenKind;
     }
     checkAny(...tokenKinds) {
         const nextKind = this.peek().kind;
-        if (nextKind === lexer_1.TokenKind.Eof) {
+        if (nextKind === TokenKind_1.TokenKind.Eof) {
             return false;
         }
         return tokenKinds.includes(nextKind);
@@ -1958,7 +2064,7 @@ class Parser {
         return tokenKinds.includes(nextKind);
     }
     isAtEnd() {
-        return this.peek().kind === lexer_1.TokenKind.Eof;
+        return this.peek().kind === TokenKind_1.TokenKind.Eof;
     }
     peekNext() {
         if (this.isAtEnd()) {
@@ -1980,16 +2086,16 @@ class Parser {
                 return;
             }
             switch (this.peek().kind) { //eslint-disable-line @typescript-eslint/switch-exhaustiveness-check
-                case lexer_1.TokenKind.Namespace:
-                case lexer_1.TokenKind.Class:
-                case lexer_1.TokenKind.Function:
-                case lexer_1.TokenKind.Sub:
-                case lexer_1.TokenKind.If:
-                case lexer_1.TokenKind.For:
-                case lexer_1.TokenKind.ForEach:
-                case lexer_1.TokenKind.While:
-                case lexer_1.TokenKind.Print:
-                case lexer_1.TokenKind.Return:
+                case TokenKind_1.TokenKind.Namespace:
+                case TokenKind_1.TokenKind.Class:
+                case TokenKind_1.TokenKind.Function:
+                case TokenKind_1.TokenKind.Sub:
+                case TokenKind_1.TokenKind.If:
+                case TokenKind_1.TokenKind.For:
+                case TokenKind_1.TokenKind.ForEach:
+                case TokenKind_1.TokenKind.While:
+                case TokenKind_1.TokenKind.Print:
+                case TokenKind_1.TokenKind.Return:
                     // start parsing again from the next block starter or obvious
                     // expression start
                     return;
@@ -2035,17 +2141,17 @@ class Parser {
         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) {
+        if (!closestToken || closestToken.kind === TokenKind_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) {
+        else if (closestToken.kind === TokenKind_1.TokenKind.Newline || previousTokenKind === TokenKind_1.TokenKind.Newline) {
             return false;
             //next to an identifier, which is next to token kind
         }
-        else if (closestToken.kind === lexer_1.TokenKind.Identifier && previousTokenKind === tokenKind) {
+        else if (closestToken.kind === TokenKind_1.TokenKind.Identifier && previousTokenKind === tokenKind) {
             return true;
         }
         else {
@@ -2056,7 +2162,7 @@ class Parser {
         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) {
+            if (currentToken.kind === TokenKind_1.TokenKind.Newline) {
                 break;
             }
             else if (currentToken.kind === tokenKind) {
@@ -2076,7 +2182,7 @@ class Parser {
         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) {
+            if (currentToken.kind === TokenKind_1.TokenKind.Newline || currentToken.kind === tokenKind) {
                 break;
             }
             tokens.push(currentToken);
@@ -2147,12 +2253,12 @@ class Parser {
             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) {
+        if ((currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_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);
+        previousTokenResult = this.getPreviousTokenIgnoreNests(currentTokenIndex, TokenKind_1.TokenKind.LeftParen, TokenKind_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) {
@@ -2160,7 +2266,7 @@ class Parser {
         }
         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);
+            previousTokenResult = this.getPreviousTokenIgnoreNests(currentTokenIndex, TokenKind_1.TokenKind.LeftSquareBracket, TokenKind_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) {
@@ -2178,15 +2284,15 @@ class Parser {
         if (!currentToken || lastTokenHasWhitespace) {
             return false;
         }
-        if (currentToken.kind === lexer_1.TokenKind.Identifier) {
+        if (currentToken.kind === TokenKind_1.TokenKind.Identifier) {
             return true;
         }
         if (currentToken.leadingWhitespace.length === 0) {
             // start of the chain
-            return lexer_1.AllowedLocalIdentifiers.includes(currentToken.kind);
+            return TokenKind_1.AllowedLocalIdentifiers.includes(currentToken.kind);
         }
         // not the start of the chain
-        return lexer_1.AllowedProperties.includes(currentToken.kind);
+        return TokenKind_1.AllowedProperties.includes(currentToken.kind);
     }
     /**
      * Builds up a chain of tokens, starting with the first in the chain, and ending with currentToken
@@ -2233,32 +2339,67 @@ class Parser {
      */
     findReferences() {
         this._references = new References();
+        const excludedExpressions = new Set();
+        const visitCallExpression = (e) => {
+            for (const p of e.args) {
+                this._references.expressions.add(p);
+            }
+            //add calls that were not excluded (from loop below)
+            if (!excludedExpressions.has(e)) {
+                this._references.expressions.add(e);
+            }
+            //if this call is part of a longer expression that includes a call higher up, find that higher one and remove it
+            if (e.callee) {
+                let node = e.callee;
+                while (node) {
+                    //the primary goal for this loop. If we found a parent call expression, remove it from `references`
+                    if ((0, reflection_1.isCallExpression)(node)) {
+                        this.references.expressions.delete(node);
+                        excludedExpressions.add(node);
+                        //stop here. even if there are multiple calls in the chain, each child will find and remove its closest parent, so that reduces excess walking.
+                        break;
+                        //when we hit a variable expression, we're definitely at the leftmost expression so stop
+                    }
+                    else if ((0, reflection_1.isVariableExpression)(node)) {
+                        break;
+                        //if
+                    }
+                    else if ((0, reflection_1.isDottedGetExpression)(node) || (0, reflection_1.isIndexedGetExpression)(node)) {
+                        node = node.obj;
+                    }
+                    else {
+                        //some expression we don't understand. log it and quit the loop
+                        this.logger.info('Encountered unknown expression while calculating function expression chain', node);
+                        break;
+                    }
+                }
+            }
+        };
         //gather up all the top-level statements
         this.ast.walk((0, visitors_1.createVisitor)({
+            AssignmentStatement: s => {
+                this._references.assignmentStatements.push(s);
+                this.references.expressions.add(s.value);
+            },
             ClassStatement: s => {
                 this._references.classStatements.push(s);
             },
+            ClassFieldStatement: s => {
+                if (s.initialValue) {
+                    this._references.expressions.add(s.initialValue);
+                }
+            },
             NamespaceStatement: s => {
                 this._references.namespaceStatements.push(s);
             },
             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)) {
@@ -2267,25 +2408,54 @@ class Parser {
             },
             NewExpression: e => {
                 this._references.newExpressions.push(e);
+                for (const p of e.call.args) {
+                    this._references.expressions.add(p);
+                }
+            },
+            ExpressionStatement: s => {
+                this._references.expressions.add(s.expression);
+            },
+            CallfuncExpression: e => {
+                visitCallExpression(e);
+            },
+            CallExpression: e => {
+                visitCallExpression(e);
             },
             AALiteralExpression: e => {
                 this.addPropertyHints(e);
+                this._references.expressions.add(e);
+                for (const member of e.elements) {
+                    if ((0, reflection_1.isAAMemberExpression)(member)) {
+                        this._references.expressions.add(member.value);
+                    }
+                }
+            },
+            ArrayLiteralExpression: e => {
+                for (const element of e.elements) {
+                    //keep everything except comments
+                    if (!(0, reflection_1.isCommentStatement)(element)) {
+                        this._references.expressions.add(element);
+                    }
+                }
             },
             DottedGetExpression: e => {
                 this.addPropertyHints(e.name);
             },
             DottedSetStatement: e => {
                 this.addPropertyHints(e.name);
+            },
+            EnumStatement: e => {
+                this._references.enumStatements.push(e);
+            },
+            UnaryExpression: e => {
+                this._references.expressions.add(e);
+            },
+            IncrementStatement: e => {
+                this._references.expressions.add(e);
             }
+        }), {
+            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));
@@ -2297,7 +2467,10 @@ class Parser {
         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));
+        return this.getContainingFunctionExpressionByPosition(currentToken.range.start);
+    }
+    getContainingFunctionExpressionByPosition(position) {
+        return this.references.functionExpressions.find((fe) => util_1.util.rangeContains(fe.range, position));
     }
     dispose() {
     }
@@ -2310,6 +2483,7 @@ var ParseMode;
 })(ParseMode = exports.ParseMode || (exports.ParseMode = {}));
 class References {
     constructor() {
+        this.cache = new Cache_1.Cache();
         this.assignmentStatements = [];
         this.classStatements = [];
         this.dottedSetStatements = [];
@@ -2317,6 +2491,18 @@ class References {
         this.functionExpressions = [];
         this.functionStatements = [];
         this.interfaceStatements = [];
+        this.enumStatements = [];
+        /**
+         * A collection of full expressions. This excludes intermediary expressions.
+         *
+         * Example 1:
+         * `a.b.c` is composed of `a` (variableExpression)  `.b` (DottedGetExpression) `.c` (DottedGetExpression)
+         * This will only contain the final `.c` DottedGetExpression because `.b` and `a` can both be derived by walking back from the `.c` DottedGetExpression.
+         *
+         * Example 2:
+         * `name.space.doSomething(a.b.c)` will result in 2 entries in this list. the `CallExpression` for `doSomething`, and the `.c` DottedGetExpression.
+         */
+        this.expressions = new Set();
         this.importStatements = [];
         this.libraryStatements = [];
         this.namespaceStatements = [];
@@ -2353,6 +2539,15 @@ class References {
         }
         return this._interfaceStatementLookup;
     }
+    get enumStatementLookup() {
+        return this.cache.getOrAdd('enums', () => {
+            const result = new Map();
+            for (const stmt of this.enumStatements) {
+                result.set(stmt.fullName.toLowerCase(), stmt);
+            }
+            return result;
+        });
+    }
 }
 exports.References = References;
 var TokenUsage;
@@ -2388,7 +2583,10 @@ function getBscTypeFromExpression(expression, functionExpression) {
             //Array literal
         }
         else if ((0, reflection_1.isArrayLiteralExpression)(expression)) {
-            return new ArrayType_1.ArrayType();
+            const innerTypes = expression.elements.filter((element) => !(0, reflection_1.isCommentStatement)(element)).map((element) => {
+                return getBscTypeFromExpression(element, functionExpression);
+            });
+            return new ArrayType_1.ArrayType(...innerTypes);
             //function call
         }
         else if ((0, reflection_1.isNewExpression)(expression)) {
@@ -2404,6 +2602,12 @@ function getBscTypeFromExpression(expression, functionExpression) {
         else if ((0, reflection_1.isDottedGetExpression)(expression)) {
             return (0, helpers_1.getTypeFromDottedGetExpression)(expression, functionExpression);
         }
+        else if ((0, reflection_1.isIndexedGetExpression)(expression)) {
+            const source = getBscTypeFromExpression(expression.obj, functionExpression);
+            if ((0, reflection_1.isArrayType)(source)) {
+                return source.getDefaultType();
+            }
+        }
     }
     catch (e) {
         //do nothing. Just return dynamic