brighterscript 1.0.0-alpha.24 → 1.0.0-alpha.26

package/dist/parser/Parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBscTypeFromExpression = exports.TokenUsage = exports.References = exports.ParseMode = exports.Parser = void 0;
+exports.ParseMode = exports.Parser = void 0;
 const Token_1 = require("../lexer/Token");
 const Lexer_1 = require("../lexer/Lexer");
 const TokenKind_1 = require("../lexer/TokenKind");
@@ -10,14 +10,8 @@ const util_1 = require("../util");
 const Expression_1 = require("./Expression");
 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 SymbolTable_1 = require("../SymbolTable");
-const DynamicType_1 = require("../types/DynamicType");
-const ArrayType_1 = require("../types/ArrayType");
-const helpers_1 = require("../types/helpers");
-const ObjectType_1 = require("../types/ObjectType");
 class Parser {
     constructor() {
         /**
@@ -27,12 +21,7 @@ class Parser {
         /**
          * The list of statements for the parsed file
          */
-        this.ast = new Statement_1.Body([]);
-        /**
-         * The top-level symbol table for this file. Things like top-level namespaces, non-namespaced classes, enums, interfaces, and functions beling here.
-         */
-        this.symbolTable = new SymbolTable_1.SymbolTable(undefined, `File Parser`);
-        this._references = new References();
+        this.ast = new Statement_1.Body({ statements: [] });
         this.globalTerminators = [];
         /**
          * An array of CallExpression for the current function body
@@ -42,48 +31,11 @@ class Parser {
     get statements() {
         return this.ast.statements;
     }
-    get currentSymbolTable() {
-        var _a, _b, _c, _d;
-        return (_d = (_b = (_a = this.currentFunctionExpression) === null || _a === void 0 ? void 0 : _a.symbolTable) !== null && _b !== void 0 ? _b : (_c = this.currentNamespace) === null || _c === void 0 ? void 0 : _c.symbolTable) !== null && _d !== void 0 ? _d : this.symbolTable;
-    }
-    /**
-     * References for significant statements/expressions in the parser.
-     * These are initially extracted during parse-time to improve performance, but will also be dynamically regenerated if need be.
-     *
-     * If a plugin modifies the AST, then the plugin should call Parser#invalidateReferences() to force this object to refresh
-     */
-    get references() {
-        //build the references object if it's missing.
-        if (!this._references) {
-            this.findReferences();
-        }
-        return this._references;
-    }
     /**
-     * Invalidates (clears) the references collection. This should be called anytime the AST has been manipulated.
+     * The top-level symbol table for the body of this file.
      */
-    invalidateReferences() {
-        this._references = undefined;
-    }
-    addPropertyHints(item) {
-        if ((0, Token_1.isToken)(item)) {
-            const name = item.text;
-            this._references.propertyHints[name.toLowerCase()] = name;
-        }
-        else {
-            for (const member of item.elements) {
-                if (!(0, reflection_1.isCommentStatement)(member)) {
-                    const name = member.keyToken.text;
-                    if (!name.startsWith('"')) {
-                        this._references.propertyHints[name.toLowerCase()] = name;
-                    }
-                }
-            }
-        }
-    }
-    get currentNamespaceName() {
-        var _a;
-        return (_a = this.currentNamespace) === null || _a === void 0 ? void 0 : _a.nameExpression;
+    get symbolTable() {
+        return this.ast.symbolTable;
     }
     /**
      * Get the currently active global terminators
@@ -125,11 +77,13 @@ class Parser {
         this.namespaceAndFunctionDepth = 0;
         this.pendingAnnotations = [];
         this.ast = this.body();
+        //now that we've built the AST, link every node to its parent
+        this.ast.link();
         return this;
     }
     body() {
         const parentAnnotations = this.enterAnnotationBlock();
-        let body = new Statement_1.Body([], this.symbolTable);
+        let body = new Statement_1.Body({ statements: [] });
         if (this.tokens.length > 0) {
             this.consumeStatementSeparators(true);
             try {
@@ -190,7 +144,7 @@ class Parser {
     declaration() {
         try {
             if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
-                return this.functionStatement({ hasName: true, hasBody: true, hasEnd: true });
+                return this.functionDeclaration(false);
             }
             if (this.checkLibrary()) {
                 return this.libraryStatement();
@@ -236,75 +190,125 @@ class Parser {
         return identifier;
     }
     enumMemberStatement() {
-        const tokens = {};
-        let value;
-        tokens.name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+        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)) {
-            tokens.equal = this.advance();
-            value = this.expression();
+            statement.tokens.equals = this.advance();
+            statement.value = this.expression();
         }
-        return new Statement_1.EnumMemberStatement(tokens, value);
+        return statement;
     }
     /**
-     * Create a new InterfaceFieldStatement. This should only be called from within `interfaceDeclaration`
+     * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration`
      */
-    interfaceFieldStatement() {
+    interfaceFieldStatement(optionalKeyword) {
         const name = this.identifier(...TokenKind_1.AllowedProperties);
         let asToken;
-        let typeExpr;
-        //look for `as SOME_TYPE`
+        let typeExpression;
         if (this.check(TokenKind_1.TokenKind.As)) {
-            asToken = this.consumeToken(TokenKind_1.TokenKind.As);
-            typeExpr = this.typeExpression();
-            //no field type specified
-            if (!typeExpr.isValidType()) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeExpr.getText())), { range: typeExpr.range }));
+            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+        }
+        return new Statement_1.InterfaceFieldStatement({ name: name, as: asToken, typeExpression: typeExpression, optional: optionalKeyword });
+    }
+    consumeAsTokenAndTypeExpression(ignoreDiagnostics = false) {
+        let asToken = this.consumeToken(TokenKind_1.TokenKind.As);
+        let typeExpression;
+        if (asToken) {
+            //if there's nothing after the `as`, add a diagnostic and continue
+            if (this.checkEndOfStatement()) {
+                if (!ignoreDiagnostics) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(asToken.text)), { range: asToken.range }));
+                }
+                //consume the statement separator
+                this.consumeStatementSeparators();
+            }
+            else if (this.peek().kind !== TokenKind_1.TokenKind.Identifier && !this.checkAny(...TokenKind_1.DeclarableTypes, ...TokenKind_1.AllowedTypeIdentifiers)) {
+                if (!ignoreDiagnostics) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(asToken.text)), { range: asToken.range }));
+                }
+            }
+            else {
+                typeExpression = this.typeExpression();
             }
         }
-        return new Statement_1.InterfaceFieldStatement(name, asToken, typeExpr, this.currentNamespaceName);
+        return [asToken, typeExpression];
+    }
+    /**
+     * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration()`
+     */
+    interfaceMethodStatement(optionalKeyword) {
+        const functionType = this.advance();
+        const name = this.identifier(...TokenKind_1.AllowedProperties);
+        const leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.LeftParen), TokenKind_1.TokenKind.LeftParen);
+        let params = [];
+        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(TokenKind_1.TokenKind.Comma));
+        }
+        const rightParen = this.consumeToken(TokenKind_1.TokenKind.RightParen);
+        // let asToken = null as Token;
+        // let returnTypeExpression: TypeExpression;
+        let asToken;
+        let returnTypeExpression;
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            [asToken, returnTypeExpression] = this.consumeAsTokenAndTypeExpression();
+        }
+        return new Statement_1.InterfaceMethodStatement({
+            functionType: functionType,
+            name: name,
+            leftParen: leftParen,
+            params: params,
+            rightParen: rightParen,
+            as: asToken,
+            returnTypeExpression: returnTypeExpression,
+            optional: optionalKeyword
+        });
     }
     interfaceDeclaration() {
         this.warnIfNotBrighterScriptMode('interface declarations');
         const parentAnnotations = this.enterAnnotationBlock();
         const interfaceToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Interface), TokenKind_1.TokenKind.Interface);
-        //get the interface name
-        let nameToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('interface'), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+        const nameToken = this.identifier(...this.allowedLocalIdentifiers);
         let extendsToken;
         let parentInterfaceName;
         if (this.peek().text.toLowerCase() === 'extends') {
             extendsToken = this.advance();
-            parentInterfaceName = this.getNamespacedVariableNameExpression();
+            if (this.checkEndOfStatement()) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(extendsToken.text)), { range: extendsToken.range }));
+            }
+            else {
+                parentInterfaceName = this.typeExpression();
+            }
         }
         this.consumeStatementSeparators();
         //gather up all interface members (Fields, Methods)
         let body = [];
         while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
             try {
-                //break out of this loop if we encountered the `EndInterface` token not followed by `as`
-                if (this.check(TokenKind_1.TokenKind.EndInterface) && !this.checkNext(TokenKind_1.TokenKind.As)) {
-                    break;
-                }
                 let decl;
                 //collect leading annotations
                 if (this.check(TokenKind_1.TokenKind.At)) {
                     this.annotationExpression();
                 }
+                const optionalKeyword = this.consumeTokenIf(TokenKind_1.TokenKind.Optional);
                 //fields
-                if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties) && this.checkNext(TokenKind_1.TokenKind.As)) {
+                if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties) && this.checkAnyNext(TokenKind_1.TokenKind.As, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
+                    decl = this.interfaceFieldStatement(optionalKeyword);
+                    //field with name = 'optional'
+                }
+                else if (optionalKeyword && this.checkAny(TokenKind_1.TokenKind.As, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
+                    //rewind one place, so that 'optional' is the field name
+                    this.current--;
                     decl = this.interfaceFieldStatement();
                     //methods (function/sub keyword followed by opening paren)
                 }
-                else if (this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub) && this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
-                    const functionStatement = this.functionStatement({
-                        hasName: true,
-                        hasBody: false,
-                        hasEnd: false,
-                        onlyCallableAsMember: true
-                    });
-                    decl = new Statement_1.InterfaceMethodStatement(functionStatement.name, functionStatement.func);
-                    //refer to this statement as parent of the expression
-                    functionStatement.func.functionStatement = decl;
+                else if (this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub) && this.checkAnyNext(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+                    decl = this.interfaceMethodStatement(optionalKeyword);
                     //comments
                 }
                 else if (this.check(TokenKind_1.TokenKind.Comment)) {
@@ -314,6 +318,10 @@ class Parser {
                     this.consumePendingAnnotations(decl);
                     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
@@ -321,24 +329,30 @@ class Parser {
             }
             //ensure statement separator
             this.consumeStatementSeparators();
+            //break out of this loop if we encountered the `EndInterface` token not followed by `as`
+            if (this.check(TokenKind_1.TokenKind.EndInterface) && !this.checkNext(TokenKind_1.TokenKind.As)) {
+                break;
+            }
         }
         //consume the final `end interface` token
-        let endingKeyword = this.advance();
-        if (endingKeyword.kind !== TokenKind_1.TokenKind.EndInterface) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('interface')), { range: endingKeyword.range }));
-        }
-        const statement = new Statement_1.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endingKeyword, this.currentNamespaceName);
-        this._references.interfaceStatements.push(statement);
+        const endInterfaceToken = this.consumeToken(TokenKind_1.TokenKind.EndInterface);
+        const statement = new Statement_1.InterfaceStatement({
+            interface: interfaceToken,
+            name: nameToken,
+            extends: extendsToken,
+            parentInterfaceName: parentInterfaceName,
+            body: body,
+            endInterface: endInterfaceToken
+        });
         this.exitAnnotationBlock(parentAnnotations);
         return statement;
     }
     enumDeclaration() {
+        const result = new Statement_1.EnumStatement({ name: {}, body: [] });
         this.warnIfNotBrighterScriptMode('enum declarations');
         const parentAnnotations = this.enterAnnotationBlock();
-        const tokens = {};
-        const body = [];
-        tokens.enum = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
-        tokens.name = this.tryIdentifier();
+        result.tokens.enum = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
+        result.tokens.name = this.tryIdentifier(...this.allowedLocalIdentifiers);
         this.consumeStatementSeparators();
         //gather up all members
         while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
@@ -358,7 +372,7 @@ class Parser {
                 }
                 if (decl) {
                     this.consumePendingAnnotations(decl);
-                    body.push(decl);
+                    result.body.push(decl);
                 }
                 else {
                     //we didn't find a declaration...flag tokens until next line
@@ -377,12 +391,7 @@ class Parser {
             }
         }
         //consume the final `end interface` token
-        tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
-        const result = new Statement_1.EnumStatement(tokens, body, this.currentNamespaceName);
-        if (tokens.name) {
-            this.currentSymbolTable.addSymbol(tokens.name.text, tokens.name.range, result.getThisBscType());
-        }
-        this._references.enumStatements.push(result);
+        result.tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
         this.exitAnnotationBlock(parentAnnotations);
         return result;
     }
@@ -400,7 +409,12 @@ class Parser {
         //see if the class inherits from parent
         if (this.peek().text.toLowerCase() === 'extends') {
             extendsKeyword = this.advance();
-            parentClassName = this.getNamespacedVariableNameExpression();
+            if (this.checkEndOfStatement()) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(extendsKeyword.text)), { range: extendsKeyword.range }));
+            }
+            else {
+                parentClassName = this.typeExpression();
+            }
         }
         //ensure statement separator
         this.consumeStatementSeparators();
@@ -423,16 +437,19 @@ class Parser {
                 }
                 //methods (function/sub keyword OR identifier followed by opening paren)
                 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 functionStatement = this.functionStatement({ hasName: true, hasBody: true, hasEnd: true, onlyCallableAsMember: true });
+                    const funcDeclaration = this.functionDeclaration(false, false);
                     //if we have an overrides keyword AND this method is called 'new', that's not allowed
-                    if (overrideKeyword && functionStatement.name.text.toLowerCase() === 'new') {
+                    if (overrideKeyword && funcDeclaration.tokens.name.text.toLowerCase() === 'new') {
                         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseOverrideKeywordOnConstructorFunction()), { range: overrideKeyword.range }));
                     }
-                    decl = new Statement_1.MethodStatement(accessModifier, functionStatement.name, functionStatement.func, overrideKeyword);
+                    decl = new Statement_1.MethodStatement({
+                        modifiers: accessModifier,
+                        name: funcDeclaration.tokens.name,
+                        func: funcDeclaration.func,
+                        override: overrideKeyword
+                    });
                     //refer to this statement as parent of the expression
-                    functionStatement.func.functionStatement = decl;
-                    //cache the range property so that plugins can't affect it
-                    decl.cacheRange();
+                    funcDeclaration.func.functionStatement = decl;
                     //fields
                 }
                 else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
@@ -462,26 +479,50 @@ class Parser {
         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);
-        if (className) {
-            this.currentSymbolTable.addSymbol(className.text, className.range, result.getConstructorFunctionType());
-        }
-        this._references.classStatements.push(result);
+        const result = new Statement_1.ClassStatement({
+            class: classKeyword,
+            name: className,
+            body: body,
+            endClass: endingKeyword,
+            extends: extendsKeyword,
+            parentClassName: parentClassName
+        });
         this.exitAnnotationBlock(parentAnnotations);
         return result;
     }
     fieldDeclaration(accessModifier) {
+        let optionalKeyword = this.consumeTokenIf(TokenKind_1.TokenKind.Optional);
+        if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+            if (this.check(TokenKind_1.TokenKind.As)) {
+                if (this.checkAnyNext(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Newline)) {
+                    // as <EOL>
+                    // `as` is the field name
+                }
+                else if (this.checkNext(TokenKind_1.TokenKind.As)) {
+                    //  as as ____
+                    // first `as` is the field name
+                }
+                else if (optionalKeyword) {
+                    // optional as ____
+                    // optional is the field name, `as` starts type
+                    // rewind current token
+                    optionalKeyword = null;
+                    this.current--;
+                }
+            }
+        }
+        else {
+            // no name after `optional` ... optional is the name
+            // rewind current token
+            optionalKeyword = null;
+            this.current--;
+        }
         let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         let asToken;
-        let fieldTypeExpr;
+        let fieldTypeExpression;
         //look for `as SOME_TYPE`
         if (this.check(TokenKind_1.TokenKind.As)) {
-            asToken = this.advance();
-            fieldTypeExpr = this.typeExpression();
-            //no field type specified
-            if (!fieldTypeExpr.isValidType(this.options.mode)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedValidTypeToFollowAsKeyword()), { range: this.peek().range }));
-            }
+            [asToken, fieldTypeExpression] = this.consumeAsTokenAndTypeExpression();
         }
         let initialValue;
         let equal;
@@ -490,43 +531,30 @@ class Parser {
             equal = this.advance();
             initialValue = this.expression();
         }
-        return new Statement_1.FieldStatement(accessModifier, name, asToken, fieldTypeExpr, equal, initialValue, this.currentNamespaceName);
-    }
-    functionStatement(options) {
-        options.hasName = true;
-        const funcResult = this.functionDeclaration(options);
-        if (funcResult) {
-            let result = new Statement_1.FunctionStatement(funcResult.name, funcResult.functionExpression, this.currentNamespaceName);
-            funcResult.functionExpression.functionStatement = result;
-            if (!options.onlyCallableAsMember) {
-                this._references.functionStatements.push(result);
-            }
-            // Add the transpiled name for namespace functions
-            // to consider an edge case when defining namespaces in .bs files
-            // and using them in .brs files.
-            if (result.func.namespaceName) {
-                const transpiledNamespaceFunctionName = result.getName(ParseMode.BrightScript);
-                const funcType = result.func.getFunctionType();
-                funcType.setName(transpiledNamespaceFunctionName);
-                this.symbolTable.addSymbol(transpiledNamespaceFunctionName, result.name.range, funcType);
-            }
-            return result;
-        }
+        return new Statement_1.FieldStatement({
+            accessModifier: accessModifier,
+            name: name,
+            as: asToken,
+            typeExpression: fieldTypeExpression,
+            equals: equal,
+            initialValue: initialValue,
+            optional: optionalKeyword
+        });
     }
-    functionDeclaration(options = {}) {
-        var _a, _b, _c;
+    functionDeclaration(isAnonymous, checkIdentifier = true, onlyCallableAsMember = false) {
+        var _a;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
         try {
             //track depth to help certain statements need to know if they are contained within a function body
             this.namespaceAndFunctionDepth++;
-            let functionKeyword;
+            let functionType;
             if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
-                functionKeyword = this.advance();
+                functionType = this.advance();
             }
             else {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingCallableKeyword()), { range: this.peek().range }));
-                functionKeyword = {
+                functionType = {
                     isReserved: true,
                     kind: TokenKind_1.TokenKind.Function,
                     text: 'function',
@@ -535,33 +563,34 @@ class Parser {
                         start: this.peek().range.start,
                         end: this.peek().range.start
                     },
-                    leadingWhitespace: ''
+                    leadingWhitespace: '',
+                    leadingTrivia: []
                 };
             }
-            let isSub = (functionKeyword === null || functionKeyword === void 0 ? void 0 : functionKeyword.kind) === TokenKind_1.TokenKind.Sub;
-            let functionKeywordText = isSub ? 'sub' : 'function';
+            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 (!options.hasName) {
-                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallable(functionKeywordText), TokenKind_1.TokenKind.LeftParen);
+            if (isAnonymous) {
+                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallable(functionTypeText), TokenKind_1.TokenKind.LeftParen);
             }
             else {
-                name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedNameAfterCallableKeyword(functionKeywordText), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
-                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallableName(functionKeywordText), TokenKind_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)) {
                     //don't throw this error; let the parser continue
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionNameCannotEndWithTypeDesignator(functionKeywordText, name.text, lastChar)), { range: name.range }));
+                    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 - not for class methods)
-                if (!options.onlyCallableAsMember && TokenKind_1.DisallowedFunctionIdentifiersText.has(name.text.toLowerCase())) {
+                //flag functions with keywords for names (only for standard functions)
+                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 typeExpr;
+            let typeExpression;
             if (!this.check(TokenKind_1.TokenKind.RightParen)) {
                 do {
                     if (params.length >= Expression_1.CallExpression.MaximumArguments) {
@@ -572,69 +601,57 @@ class Parser {
             }
             let rightParen = this.advance();
             if (this.check(TokenKind_1.TokenKind.As)) {
-                asToken = this.advance();
-                typeExpr = this.typeExpression();
-                if (!typeExpr.isValidType(this.options.mode)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType((_a = typeExpr.getText()) !== null && _a !== void 0 ? _a : '')), { range: typeExpr.range }));
-                }
+                [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
             }
             params.reduce((haveFoundOptional, param) => {
                 if (haveFoundOptional && !param.defaultValue) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.requiredParameterMayNotFollowOptionalParameter(param.name.text)), { range: param.range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.requiredParameterMayNotFollowOptionalParameter(param.tokens.name.text)), { range: param.range }));
                 }
                 return haveFoundOptional || !!param.defaultValue;
             }, false);
-            if (options.hasEnd && options.hasBody) {
-                // do not go to next statement - we don't care about any other statement
-                this.consumeStatementSeparators(true);
+            this.consumeStatementSeparators(true);
+            let func = new Expression_1.FunctionExpression({
+                parameters: params,
+                body: undefined,
+                functionType: functionType,
+                endFunctionType: undefined,
+                leftParen: leftParen,
+                rightParen: rightParen,
+                as: asToken,
+                returnTypeExpression: typeExpression
+            });
+            //support ending the function with `end sub` OR `end function`
+            func.body = this.block();
+            //if the parser was unable to produce a block, make an empty one so the AST makes some sense...
+            if (!func.body) {
+                func.body = new Statement_1.Block({
+                    statements: [],
+                    startingRange: util_1.util.createRangeFromPositions(func.range.start, func.range.start)
+                });
             }
-            // Can Not use the current function expression symbol table for a function expression inside of itself
-            const funcExprParentSymbolTable = (_c = (_b = this.currentNamespace) === null || _b === void 0 ? void 0 : _b.symbolTable) !== null && _c !== void 0 ? _c : this.symbolTable;
-            let func = new Expression_1.FunctionExpression(params, undefined, //body
-            functionKeyword, undefined, //ending keyword
-            leftParen, rightParen, asToken, typeExpr, //return type
-            this.currentFunctionExpression, this.currentNamespaceName, funcExprParentSymbolTable);
-            //if there is a parent function, register this function with the parent
-            if (this.currentFunctionExpression) {
-                this.currentFunctionExpression.childFunctionExpressions.push(func);
-            }
-            // add the function to the relevant symbol tables
-            if (!options.onlyCallableAsMember && name) {
-                const funcType = func.getFunctionType();
-                funcType.setName(name.text);
-                // add the function as declared to the current symbol table
-                this.currentSymbolTable.addSymbol(name.text, name.range, funcType);
-            }
-            this._references.functionExpressions.push(func);
-            if (options.hasBody) {
-                let previousFunctionExpression = this.currentFunctionExpression;
-                this.currentFunctionExpression = func;
-                //make sure to restore the currentFunctionExpression even if the body block fails to parse
-                try {
-                    //support ending the function with `end sub` OR `end function`
-                    func.body = this.block();
-                }
-                finally {
-                    this.currentFunctionExpression = previousFunctionExpression;
-                }
-                if (!func.body) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callableBlockMissingEndKeyword(functionKeywordText)), { range: this.peek().range }));
-                    throw this.lastDiagnosticAsError();
-                }
+            func.body.symbolTable = new SymbolTable_1.SymbolTable(`Block: Function '${(_a = name === null || name === void 0 ? void 0 : name.text) !== null && _a !== void 0 ? _a : ''}'`, () => func.getSymbolTable());
+            if (!func.body) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callableBlockMissingEndKeyword(functionTypeText)), { range: this.peek().range }));
+                throw this.lastDiagnosticAsError();
             }
-            if (options.hasEnd) {
-                // consume 'end sub' or 'end function'
-                func.end = this.advance();
-                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) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndCallableKeyword(functionKeywordText, func.end.text)), { range: this.peek().range }));
-                }
+            // consume 'end sub' or 'end function'
+            func.tokens.endFunctionType = this.advance();
+            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.tokens.endFunctionType.kind !== expectedEndKind) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndCallableKeyword(functionTypeText, func.tokens.endFunctionType.text)), { range: func.tokens.endFunctionType.range }));
             }
             func.callExpressions = this.callExpressions;
-            func.cacheRange();
-            return { name: name, functionExpression: func };
+            if (isAnonymous) {
+                return func;
+            }
+            else {
+                let result = new Statement_1.FunctionStatement({ name: name, func: func });
+                func.symbolTable.name += `: '${name === null || name === void 0 ? void 0 : name.text}'`;
+                func.functionStatement = result;
+                return result;
+            }
         }
         finally {
             this.namespaceAndFunctionDepth--;
@@ -647,65 +664,62 @@ class Parser {
             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(...TokenKind_1.AllowedLocalIdentifiers);
-        let typeExpr;
+        let name = this.advance();
+        // force the name into an identifier so the AST makes some sense
+        name.kind = TokenKind_1.TokenKind.Identifier;
+        let typeExpression;
         let defaultValue;
-        let equalsToken;
+        let equalToken;
         // parse argument default value
-        if (this.match(TokenKind_1.TokenKind.Equal)) {
-            equalsToken = this.previous();
+        if ((equalToken = this.consumeTokenIf(TokenKind_1.TokenKind.Equal))) {
             // it seems any expression is allowed here -- including ones that operate on other arguments!
-            defaultValue = this.expression();
+            defaultValue = this.expression(false);
         }
         let asToken = null;
         if (this.check(TokenKind_1.TokenKind.As)) {
-            asToken = this.advance();
-            typeExpr = this.typeExpression();
-            if (!typeExpr.isValidType(this.options.mode)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeExpr.getText())), { range: typeExpr.range }));
-                throw this.lastDiagnosticAsError();
-            }
-        }
-        let typeInContext;
-        if (typeExpr) {
-            typeInContext = typeExpr.type;
-        }
-        else if (defaultValue) {
-            typeInContext = getBscTypeFromExpression(defaultValue, this.currentFunctionExpression);
-            if ((0, reflection_1.isInvalidType)(typeInContext)) {
-                typeInContext = new DynamicType_1.DynamicType();
-            }
-        }
-        else {
-            typeInContext = new DynamicType_1.DynamicType();
-        }
-        return new Expression_1.FunctionParameterExpression(name, typeInContext, equalsToken, defaultValue, asToken, typeExpr, this.currentNamespaceName);
+            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+        }
+        return new Expression_1.FunctionParameterExpression({
+            name: name,
+            equals: equalToken,
+            defaultValue: defaultValue,
+            as: asToken,
+            typeExpression: typeExpression
+        });
     }
     assignment() {
-        let name = this.identifier(...this.allowedLocalIdentifiers);
+        let name = this.advance();
         //add diagnostic if name is a reserved word that cannot be used as an identifier
         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 asToken;
+        let typeExpression;
+        //look for `as SOME_TYPE`
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            this.warnIfNotBrighterScriptMode('typed assignment');
+            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+        }
         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 === TokenKind_1.TokenKind.Equal) {
-            result = new Statement_1.AssignmentStatement(name, operator, value, this.currentFunctionExpression);
+            result = new Statement_1.AssignmentStatement({ equals: operator, name: name, value: value, as: asToken, typeExpression: typeExpression });
         }
         else {
-            const nameExpression = new Expression_1.VariableExpression(name, this.currentNamespaceName);
-            result = new Statement_1.AssignmentStatement(name, operator, new Expression_1.BinaryExpression(nameExpression, operator, value), this.currentFunctionExpression);
-            this.addExpressionsToReferences(nameExpression);
-            if ((0, reflection_1.isBinaryExpression)(value)) {
-                //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);
-        this.currentSymbolTable.addSymbol(name.text, name.range, assignmentType);
+            const nameExpression = new Expression_1.VariableExpression({ name: name });
+            result = new Statement_1.AssignmentStatement({
+                equals: operator,
+                name: name,
+                value: new Expression_1.BinaryExpression({
+                    left: nameExpression,
+                    operator: operator,
+                    right: value
+                }),
+                as: asToken,
+                typeExpression: typeExpression
+            });
+        }
         return result;
     }
     checkLibrary() {
@@ -774,6 +788,10 @@ class Parser {
         if (this.check(TokenKind_1.TokenKind.Goto)) {
             return this.gotoStatement();
         }
+        //the continue keyword (followed by `for`, `while`, or a statement separator)
+        if (this.check(TokenKind_1.TokenKind.Continue) && this.checkAnyNext(TokenKind_1.TokenKind.While, TokenKind_1.TokenKind.For, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
+            return this.continueStatement();
+        }
         //does this line look like a label? (i.e.  `someIdentifier:` )
         if (this.check(TokenKind_1.TokenKind.Identifier) && this.checkNext(TokenKind_1.TokenKind.Colon) && this.checkPrevious(TokenKind_1.TokenKind.Newline)) {
             try {
@@ -789,9 +807,31 @@ 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(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers) &&
-            this.checkAnyNext(...TokenKind_1.AssignmentOperators)) {
-            return this.assignment();
+        if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+            if (this.checkAnyNext(...TokenKind_1.AssignmentOperators)) {
+                return this.assignment();
+            }
+            else if (this.checkNext(TokenKind_1.TokenKind.As)) {
+                // may be a typed assignment
+                const backtrack = this.current;
+                let validTypeExpression = false;
+                try {
+                    // skip the identifier, and check for valid type expression
+                    this.advance();
+                    const parts = this.consumeAsTokenAndTypeExpression(true);
+                    validTypeExpression = !!((parts === null || parts === void 0 ? void 0 : parts[0]) && (parts === null || parts === void 0 ? void 0 : parts[1]));
+                }
+                catch (e) {
+                    // ignore any errors
+                }
+                finally {
+                    this.current = backtrack;
+                }
+                if (validTypeExpression) {
+                    // there is a valid 'as' and type expression
+                    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(TokenKind_1.TokenKind.Interface)) {
@@ -824,7 +864,12 @@ class Parser {
         else {
             endWhile = this.advance();
         }
-        return new Statement_1.WhileStatement({ while: whileKeyword, endWhile: endWhile }, condition, whileBlock);
+        return new Statement_1.WhileStatement({
+            while: whileKeyword,
+            endWhile: endWhile,
+            condition: condition,
+            body: whileBlock
+        });
     }
     exitWhile() {
         let keyword = this.advance();
@@ -859,11 +904,20 @@ class Parser {
         }
         // WARNING: BrightScript doesn't delete the loop initial value after a for/to loop! It just
         // stays around in scope with whatever value it was when the loop exited.
-        return new Statement_1.ForStatement(forToken, initializer, toToken, finalValue, body, endForToken, stepToken, incrementExpression);
+        return new Statement_1.ForStatement({
+            for: forToken,
+            counterDeclaration: initializer,
+            to: toToken,
+            finalValue: finalValue,
+            body: body,
+            endFor: endForToken,
+            step: stepToken,
+            increment: incrementExpression
+        });
     }
     forEachStatement() {
         let forEach = this.advance();
-        let name = this.identifier(...this.allowedLocalIdentifiers);
+        let name = this.advance();
         let maybeIn = this.peek();
         if (this.check(TokenKind_1.TokenKind.Identifier) && maybeIn.text.toLowerCase() === 'in') {
             this.advance();
@@ -877,12 +931,6 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedExpressionAfterForEachIn()), { range: this.peek().range }));
             throw this.lastDiagnosticAsError();
         }
-        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);
         this.consumeStatementSeparators();
         let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next);
         if (!body) {
@@ -890,7 +938,14 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         let endFor = this.advance();
-        return new Statement_1.ForEachStatement(forEach, name, maybeIn, target, body, endFor);
+        return new Statement_1.ForEachStatement({
+            forEach: forEach,
+            in: maybeIn,
+            endFor: endFor,
+            item: name,
+            target: target,
+            body: body
+        });
     }
     exitFor() {
         let keyword = this.advance();
@@ -901,7 +956,7 @@ class Parser {
         //then this comment should be treated as a single-line comment
         let prev = this.previous();
         if ((prev === null || prev === void 0 ? void 0 : prev.range.end.line) === this.peek().range.start.line) {
-            return new Statement_1.CommentStatement([this.advance()]);
+            return new Statement_1.CommentStatement({ comments: [this.advance()] });
         }
         else {
             let comments = [this.advance()];
@@ -909,25 +964,19 @@ class Parser {
                 this.advance();
                 comments.push(this.advance());
             }
-            return new Statement_1.CommentStatement(comments);
+            return new Statement_1.CommentStatement({ comments: comments });
         }
     }
     namespaceStatement() {
         this.warnIfNotBrighterScriptMode('namespace');
         let keyword = this.advance();
-        if (!this.isAtRootLevel()) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtRootLevel('namespace')), { range: keyword.range }));
-        }
         this.namespaceAndFunctionDepth++;
-        let name = this.getNamespacedVariableNameExpression();
+        let name = this.identifyingExpression();
         //set the current namespace name
-        let result = new Statement_1.NamespaceStatement(keyword, name, null, null, this.currentSymbolTable);
-        this.currentNamespace = result;
+        let result = new Statement_1.NamespaceStatement({ namespace: keyword, nameExpression: name, body: null });
         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(TokenKind_1.TokenKind.EndNamespace)) {
             endKeyword = this.advance();
@@ -938,25 +987,23 @@ class Parser {
         }
         this.namespaceAndFunctionDepth--;
         result.body = body;
-        result.endKeyword = endKeyword;
-        this._references.namespaceStatements.push(result);
+        result.tokens.endNamespace = endKeyword;
         //cache the range property so that plugins can't affect it
         result.cacheRange();
-        if (result.name) {
-            this.symbolTable.addSymbol(result.name.split('.')[0], result.nameExpression.range, DynamicType_1.DynamicType.instance);
-        }
+        result.body.symbolTable.name += `: namespace '${result.name}'`;
         return result;
     }
     /**
      * 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), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+    identifyingExpression(allowedTokenKinds) {
+        allowedTokenKinds = allowedTokenKinds !== null && allowedTokenKinds !== void 0 ? allowedTokenKinds : this.allowedLocalIdentifiers;
+        let firstIdentifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(this.previous().text), TokenKind_1.TokenKind.Identifier, ...allowedTokenKinds);
         let expr;
         if (firstIdentifier) {
             // force it into an identifier so the AST makes some sense
             firstIdentifier.kind = TokenKind_1.TokenKind.Identifier;
-            const varExpr = new Expression_1.VariableExpression(firstIdentifier, null);
+            const varExpr = new Expression_1.VariableExpression({ name: firstIdentifier });
             expr = varExpr;
             //consume multiple dot identifiers (i.e. `Name.Space.Can.Have.Many.Parts`)
             while (this.check(TokenKind_1.TokenKind.Dot)) {
@@ -964,16 +1011,16 @@ class Parser {
                 if (!dot) {
                     break;
                 }
-                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers, ...TokenKind_1.AllowedProperties);
+                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...allowedTokenKinds, ...TokenKind_1.AllowedProperties);
                 if (!identifier) {
                     break;
                 }
                 // force it into an identifier so the AST makes some sense
                 identifier.kind = TokenKind_1.TokenKind.Identifier;
-                expr = new Expression_1.DottedGetExpression(expr, identifier, dot);
+                expr = new Expression_1.DottedGetExpression({ obj: expr, name: identifier, dot: dot });
             }
         }
-        return new Expression_1.NamespacedVariableNameExpression(expr);
+        return expr;
     }
     /**
      * Add an 'unexpected token' diagnostic for any token found between current and the first stopToken found.
@@ -986,8 +1033,8 @@ class Parser {
     }
     /**
      * Consume tokens until one of the `stopTokenKinds` is encountered
-     * @param tokenKinds
-     * @return - the list of tokens consumed, EXCLUDING the `stopTokenKind` (you can use `this.peek()` to see which one it was)
+     * @param stopTokenKinds a list of tokenKinds where any tokenKind in this list will result in a match
+     * @returns - the list of tokens consumed, EXCLUDING the `stopTokenKind` (you can use `this.peek()` to see which one it was)
      */
     consumeUntil(...stopTokenKinds) {
         let result = [];
@@ -1006,12 +1053,9 @@ class Parser {
         const statement = new Statement_1.ConstStatement({
             const: constToken,
             name: nameToken,
-            equals: equalToken
-        }, expression, this.currentNamespaceName);
-        if (nameToken) {
-            this.currentSymbolTable.addSymbol(nameToken.text, nameToken.range, getBscTypeFromExpression(expression));
-        }
-        this._references.constStatements.push(statement);
+            equals: equalToken,
+            value: expression
+        });
         return statement;
     }
     libraryStatement() {
@@ -1020,15 +1064,15 @@ class Parser {
             //grab the next token only if it's a string
             filePath: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('library'), TokenKind_1.TokenKind.StringLiteral)
         });
-        this._references.libraryStatements.push(libStatement);
         return libStatement;
     }
     importStatement() {
         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'), TokenKind_1.TokenKind.StringLiteral));
-        this._references.importStatements.push(importStatement);
+        let importStatement = new Statement_1.ImportStatement({
+            import: this.advance(),
+            //grab the next token only if it's a string
+            filePath: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import'), TokenKind_1.TokenKind.StringLiteral)
+        });
         return importStatement;
     }
     annotationExpression() {
@@ -1037,15 +1081,13 @@ class Parser {
         if (identifier) {
             identifier.kind = TokenKind_1.TokenKind.Identifier;
         }
-        let annotation = new Expression_1.AnnotationExpression(atToken, identifier);
+        let annotation = new Expression_1.AnnotationExpression({ at: atToken, name: identifier });
         this.pendingAnnotations.push(annotation);
         //optional arguments
         if (this.check(TokenKind_1.TokenKind.LeftParen)) {
             let leftParen = this.advance();
             annotation.call = this.finishCall(leftParen, annotation, false);
         }
-        //cache the range property so that plugins can't affect it
-        annotation.cacheRange();
         return annotation;
     }
     ternaryExpression(test) {
@@ -1077,13 +1119,23 @@ class Parser {
             alternate = this.expression();
         }
         catch (_b) { }
-        return new Expression_1.TernaryExpression(test, questionMarkToken, consequent, colonToken, alternate);
+        return new Expression_1.TernaryExpression({
+            test: test,
+            questionMark: questionMarkToken,
+            consequent: consequent,
+            colon: colonToken,
+            alternate: alternate
+        });
     }
     nullCoalescingExpression(test) {
         this.warnIfNotBrighterScriptMode('null coalescing operator');
         const questionQuestionToken = this.advance();
         const alternate = this.expression();
-        return new Expression_1.NullCoalescingExpression(test, questionQuestionToken, alternate);
+        return new Expression_1.NullCoalescingExpression({
+            consequent: test,
+            questionQuestion: questionQuestionToken,
+            alternate: alternate
+        });
     }
     regexLiteralExpression() {
         this.warnIfNotBrighterScriptMode('regular expression literal');
@@ -1109,16 +1161,16 @@ class Parser {
             let next = this.peek();
             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));
+                currentQuasiExpressionParts.push(new Expression_1.LiteralExpression({ value: next }));
                 this.advance();
             }
             else if (next.kind === TokenKind_1.TokenKind.EscapedCharCodeLiteral) {
-                currentQuasiExpressionParts.push(new Expression_1.EscapedCharCodeLiteralExpression(next));
+                currentQuasiExpressionParts.push(new Expression_1.EscapedCharCodeLiteralExpression({ value: next }));
                 this.advance();
             }
             else {
                 //finish up the current quasi
-                quasis.push(new Expression_1.TemplateStringQuasiExpression(currentQuasiExpressionParts));
+                quasis.push(new Expression_1.TemplateStringQuasiExpression({ expressions: currentQuasiExpressionParts }));
                 currentQuasiExpressionParts = [];
                 if (next.kind === TokenKind_1.TokenKind.TemplateStringExpressionBegin) {
                     this.advance();
@@ -1136,7 +1188,7 @@ class Parser {
             }
         }
         //store the final set of quasis
-        quasis.push(new Expression_1.TemplateStringQuasiExpression(currentQuasiExpressionParts));
+        quasis.push(new Expression_1.TemplateStringQuasiExpression({ expressions: currentQuasiExpressionParts }));
         if (this.isAtEnd()) {
             //error - missing backtick
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unterminatedTemplateStringAtEndOfFile()), { range: util_1.util.getRange(openingBacktick, this.peek()) }));
@@ -1145,10 +1197,21 @@ class Parser {
         else {
             let closingBacktick = this.advance();
             if (isTagged) {
-                return new Expression_1.TaggedTemplateStringExpression(tagName, openingBacktick, quasis, expressions, closingBacktick);
+                return new Expression_1.TaggedTemplateStringExpression({
+                    tagName: tagName,
+                    openingBacktick: openingBacktick,
+                    quasis: quasis,
+                    expressions: expressions,
+                    closingBacktick: closingBacktick
+                });
             }
             else {
-                return new Expression_1.TemplateStringExpression(openingBacktick, quasis, expressions, closingBacktick);
+                return new Expression_1.TemplateStringExpression({
+                    openingBacktick: openingBacktick,
+                    quasis: quasis,
+                    expressions: expressions,
+                    closingBacktick: closingBacktick
+                });
             }
         }
     }
@@ -1173,7 +1236,7 @@ class Parser {
         if (exceptionVarToken) {
             // force it into an identifier so the AST makes some sense
             exceptionVarToken.kind = TokenKind_1.TokenKind.Identifier;
-            catchStmt.exceptionVariable = exceptionVarToken;
+            catchStmt.tokens.exceptionVariable = exceptionVarToken;
         }
         //ensure statement sepatator
         this.consumeStatementSeparators();
@@ -1184,9 +1247,6 @@ class Parser {
         else {
             statement.tokens.endTry = this.advance();
         }
-        if (exceptionVarToken) {
-            this.currentSymbolTable.addSymbol(exceptionVarToken.text, exceptionVarToken.range, DynamicType_1.DynamicType.instance);
-        }
         return statement;
     }
     throwStatement() {
@@ -1198,7 +1258,7 @@ class Parser {
         else {
             expression = this.expression();
         }
-        return new Statement_1.ThrowStatement(throwToken, expression);
+        return new Statement_1.ThrowStatement({ throw: throwToken, expression: expression });
     }
     dimStatement() {
         const dim = this.advance();
@@ -1229,10 +1289,13 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExpressionsInDimStatement()), { range: this.peek().range }));
         }
         let rightSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingRightSquareBracketAfterDimIdentifier(), TokenKind_1.TokenKind.RightSquareBracket);
-        if (identifier) {
-            this.currentSymbolTable.addSymbol(identifier.text, identifier.range, new ArrayType_1.ArrayType(DynamicType_1.DynamicType.instance));
-        }
-        return new Statement_1.DimStatement(dim, identifier, leftSquareBracket, expressions, rightSquareBracket);
+        return new Statement_1.DimStatement({
+            dim: dim,
+            name: identifier,
+            openingSquare: leftSquareBracket,
+            dimensions: expressions,
+            closingSquare: rightSquareBracket
+        });
     }
     ifStatement() {
         // colon before `if` is usually not allowed, unless it's after `then`
@@ -1342,8 +1405,12 @@ class Parser {
             if: ifToken,
             then: thenToken,
             endIf: endIfToken,
-            else: elseToken
-        }, condition, thenBranch, elseBranch, isInlineIfThen);
+            else: elseToken,
+            condition: condition,
+            thenBranch: thenBranch,
+            elseBranch: elseBranch,
+            isInline: isInlineIfThen
+        });
     }
     //consume a `then` or `else` branch block of an `if` statement
     blockConditionalBranch(ifToken) {
@@ -1414,7 +1481,7 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(colon.text)), { range: colon.range }));
             }
         }
-        return new Statement_1.Block(statements, startingRange);
+        return new Statement_1.Block({ statements: statements, startingRange: startingRange });
     }
     expressionStatement(expr) {
         let expressionStart = this.peek();
@@ -1428,18 +1495,15 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.incrementDecrementOperatorsAreNotAllowedAsResultOfFunctionCall()), { range: expressionStart.range }));
                 throw this.lastDiagnosticAsError();
             }
-            const result = new Statement_1.IncrementStatement(expr, operator);
-            this._references.expressions.add(result);
+            const result = new Statement_1.IncrementStatement({ value: expr, operator: operator });
             return result;
         }
         if ((0, reflection_1.isCallExpression)(expr) || (0, reflection_1.isCallfuncExpression)(expr)) {
-            return new Statement_1.ExpressionStatement(expr);
+            return new Statement_1.ExpressionStatement({ expression: expr });
         }
-        //at this point, it's probably an error. However, we recover a little more gracefully by creating an assignment
+        //at this point, it's probably an error. However, we recover a little more gracefully by creating an inclosing ExpressionStatement
         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression()), { range: expressionStart.range }));
-        // we can also add this expression to the references, for type checking purposes
-        this._references.expressions.add(expr);
-        throw this.lastDiagnosticAsError();
+        return new Statement_1.ExpressionStatement({ expression: expr });
     }
     setStatement() {
         /**
@@ -1455,19 +1519,31 @@ class Parser {
             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 === TokenKind_1.TokenKind.Equal
-                    ? right
-                    : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare, operator);
+                return new Statement_1.IndexedSetStatement({
+                    obj: left.obj,
+                    indexes: left.indexes,
+                    value: operator.kind === TokenKind_1.TokenKind.Equal
+                        ? right
+                        : new Expression_1.BinaryExpression({ left: left, operator: operator, right: right }),
+                    openingSquare: left.tokens.openingSquare,
+                    closingSquare: left.tokens.closingSquare
+                });
             }
             else if ((0, reflection_1.isDottedGetExpression)(left)) {
-                const dottedSetStmt = new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === TokenKind_1.TokenKind.Equal ? right : new Expression_1.BinaryExpression(left, operator, right), left.dot, operator);
-                this._references.dottedSetStatements.push(dottedSetStmt);
-                return dottedSetStmt;
+                return new Statement_1.DottedSetStatement({
+                    obj: left.obj,
+                    name: left.tokens.name,
+                    value: operator.kind === TokenKind_1.TokenKind.Equal
+                        ? right
+                        : new Expression_1.BinaryExpression({ left: left, operator: operator, right: right }),
+                    dot: left.tokens.dot
+                });
             }
         }
         return this.expressionStatement(expr);
     }
     printStatement() {
+        var _a;
         let printKeyword = this.advance();
         let values = [];
         while (!this.checkEndOfStatement()) {
@@ -1486,34 +1562,35 @@ class Parser {
         }
         //print statements can be empty, so look for empty print conditions
         if (!values.length) {
-            let emptyStringLiteral = (0, creators_1.createStringLiteral)('');
+            const endOfStatementRange = util_1.util.createRangeFromPositions(printKeyword.range.end, (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.range.end);
+            let emptyStringLiteral = (0, creators_1.createStringLiteral)('', endOfStatementRange);
             values.push(emptyStringLiteral);
         }
         let last = values[values.length - 1];
         if ((0, Token_1.isToken)(last)) {
             // TODO: error, expected value
         }
-        return new Statement_1.PrintStatement({ print: printKeyword }, values);
+        return new Statement_1.PrintStatement({ print: printKeyword, expressions: values });
     }
     /**
      * Parses a return statement with an optional return value.
      * @returns an AST representation of a return statement.
      */
     returnStatement() {
-        let tokens = { return: this.previous() };
+        let options = { return: this.previous() };
         if (this.checkEndOfStatement()) {
-            return new Statement_1.ReturnStatement(tokens);
+            return new Statement_1.ReturnStatement(options);
         }
         let toReturn = this.check(TokenKind_1.TokenKind.Else) ? undefined : this.expression();
-        return new Statement_1.ReturnStatement(tokens, toReturn);
+        return new Statement_1.ReturnStatement(Object.assign(Object.assign({}, options), { value: toReturn }));
     }
     /**
      * Parses a `label` statement
      * @returns an AST representation of an `label` statement.
      */
     labelStatement() {
-        let tokens = {
-            identifier: this.advance(),
+        let options = {
+            name: this.advance(),
             colon: this.advance()
         };
         //label must be alone on its line, this is probably not a label
@@ -1522,9 +1599,16 @@ class Parser {
             this.current -= 2;
             throw new CancelStatementError();
         }
-        const stmt = new Statement_1.LabelStatement(tokens);
-        this.currentFunctionExpression.labelStatements.push(stmt);
-        return stmt;
+        return new Statement_1.LabelStatement(options);
+    }
+    /**
+     * Parses a `continue` statement
+     */
+    continueStatement() {
+        return new Statement_1.ContinueStatement({
+            continue: this.advance(),
+            loopType: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.While, TokenKind_1.TokenKind.For), TokenKind_1.TokenKind.While, TokenKind_1.TokenKind.For)
+        });
     }
     /**
      * Parses a `goto` statement
@@ -1542,16 +1626,16 @@ class Parser {
      * @returns an AST representation of an `end` statement.
      */
     endStatement() {
-        let endTokens = { end: this.advance() };
-        return new Statement_1.EndStatement(endTokens);
+        let options = { end: this.advance() };
+        return new Statement_1.EndStatement(options);
     }
     /**
      * Parses a `stop` statement
      * @returns an AST representation of a `stop` statement
      */
     stopStatement() {
-        let tokens = { stop: this.advance() };
-        return new Statement_1.StopStatement(tokens);
+        let options = { stop: this.advance() };
+        return new Statement_1.StopStatement(options);
     }
     /**
      * Parses a block, looking for a specific terminating TokenKind to denote completion.
@@ -1603,7 +1687,7 @@ class Parser {
             }
         }
         this.exitAnnotationBlock(parentAnnotations);
-        return new Statement_1.Block(statements, startingToken.range);
+        return new Statement_1.Block({ statements: statements, startingRange: startingToken.range });
     }
     /**
      * Attach pending annotations to the provided statement,
@@ -1629,14 +1713,32 @@ class Parser {
         }
         this.pendingAnnotations = parentAnnotations;
     }
-    expression() {
-        const expression = this.anonymousFunction();
-        this._references.expressions.add(expression);
+    expression(findTypeCast = true) {
+        let expression = this.anonymousFunction();
+        let asToken;
+        let typeExpression;
+        if (findTypeCast) {
+            do {
+                if (this.check(TokenKind_1.TokenKind.As)) {
+                    this.warnIfNotBrighterScriptMode('type cast');
+                    // Check if this expression is wrapped in any type casts
+                    // allows for multiple casts:
+                    // myVal = foo() as dynamic as string
+                    [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+                    if (asToken && typeExpression) {
+                        expression = new Expression_1.TypeCastExpression({ obj: expression, as: asToken, typeExpression: typeExpression });
+                    }
+                }
+                else {
+                    break;
+                }
+            } while (asToken && typeExpression);
+        }
         return expression;
     }
     anonymousFunction() {
         if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
-            const func = this.functionDeclaration({ hasName: false, hasBody: true, hasEnd: true }).functionExpression;
+            const func = this.functionDeclaration(true);
             //if there's an open paren after this, this is an IIFE
             if (this.check(TokenKind_1.TokenKind.LeftParen)) {
                 return this.finishCall(this.advance(), func);
@@ -1661,8 +1763,7 @@ class Parser {
         while (this.matchAny(TokenKind_1.TokenKind.And, TokenKind_1.TokenKind.Or)) {
             let operator = this.previous();
             let right = this.relational();
-            this.addExpressionsToReferences(expr, right);
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
@@ -1671,26 +1772,17 @@ class Parser {
         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();
-            this.addExpressionsToReferences(expr, right);
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
-    addExpressionsToReferences(...expressions) {
-        for (const expression of expressions) {
-            if (!(0, reflection_1.isBinaryExpression)(expression)) {
-                this.references.expressions.add(expression);
-            }
-        }
-    }
     // TODO: bitshift
     additive() {
         let expr = this.multiplicative();
         while (this.matchAny(TokenKind_1.TokenKind.Plus, TokenKind_1.TokenKind.Minus)) {
             let operator = this.previous();
             let right = this.multiplicative();
-            this.addExpressionsToReferences(expr, right);
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
@@ -1699,8 +1791,7 @@ class Parser {
         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();
-            this.addExpressionsToReferences(expr, right);
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
@@ -1709,40 +1800,74 @@ class Parser {
         while (this.match(TokenKind_1.TokenKind.Caret)) {
             let operator = this.previous();
             let right = this.prefixUnary();
-            this.addExpressionsToReferences(expr, right);
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
     prefixUnary() {
         const nextKind = this.peek().kind;
-        if (nextKind === TokenKind_1.TokenKind.Not || nextKind === TokenKind_1.TokenKind.Minus) {
+        if (nextKind === TokenKind_1.TokenKind.Not) {
             this.current++; //advance
             let operator = this.previous();
-            let right = this.prefixUnary();
-            return new Expression_1.UnaryExpression(operator, right);
+            let right = this.relational();
+            return new Expression_1.UnaryExpression({ operator: operator, right: right });
+        }
+        else if (nextKind === TokenKind_1.TokenKind.Minus || nextKind === TokenKind_1.TokenKind.Plus) {
+            this.current++; //advance
+            let operator = this.previous();
+            let right = nextKind === TokenKind_1.TokenKind.Not
+                ? this.boolean()
+                : this.prefixUnary();
+            return new Expression_1.UnaryExpression({ operator: operator, right: right });
         }
         return this.call();
     }
     indexedGet(expr) {
         let openingSquare = this.previous();
         let questionDotToken = this.getMatchingTokenAtOffset(-2, TokenKind_1.TokenKind.QuestionDot);
+        let indexes = [];
+        //consume leading newlines
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
-        let index = this.expression();
+        try {
+            indexes.push(this.expression());
+            //consume additional indexes separated by commas
+            while (this.check(TokenKind_1.TokenKind.Comma)) {
+                //discard the comma
+                this.advance();
+                indexes.push(this.expression());
+            }
+        }
+        catch (error) {
+            this.rethrowNonDiagnosticError(error);
+        }
+        //consume trailing newlines
         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, questionDotToken);
+        const closingSquare = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedRightSquareBraceAfterArrayOrObjectIndex(), TokenKind_1.TokenKind.RightSquareBracket);
+        return new Expression_1.IndexedGetExpression({
+            obj: expr,
+            indexes: indexes,
+            openingSquare: openingSquare,
+            closingSquare: closingSquare,
+            questionDot: questionDotToken
+        });
     }
     newExpression() {
+        var _a;
         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), TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen);
+        let nameExpr = this.identifyingExpression();
+        let leftParen = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen);
+        if (!leftParen) {
+            // new expression without a following call expression
+            // wrap the name in an expression
+            const endOfStatementRange = util_1.util.createRangeFromPositions(newToken.range.end, (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.range.end);
+            const exprStmt = nameExpr !== null && nameExpr !== void 0 ? nameExpr : (0, creators_1.createStringLiteral)('', endOfStatementRange);
+            return new Statement_1.ExpressionStatement({ expression: exprStmt });
+        }
         let call = this.finishCall(leftParen, nameExpr);
         //pop the call from the  callExpressions list because this is technically something else
         this.callExpressions.pop();
-        let result = new Expression_1.NewExpression(newToken, call);
-        this._references.newExpressions.push(result);
+        let result = new Expression_1.NewExpression({ new: newToken, call: call });
         return result;
     }
     /**
@@ -1756,28 +1881,29 @@ class Parser {
         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);
+        return new Expression_1.CallfuncExpression({
+            callee: callee,
+            operator: operator,
+            methodName: methodName,
+            openingParen: openParen,
+            args: call.args,
+            closingParen: call.tokens.closingParen
+        });
     }
     call() {
         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.matchAny(TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen)) {
                 expr = this.finishCall(this.previous(), expr);
-                //store this call expression in references
-                referenceCallExpression = expr;
             }
             else if (this.matchAny(TokenKind_1.TokenKind.LeftSquareBracket, TokenKind_1.TokenKind.QuestionLeftSquare) || this.matchSequence(TokenKind_1.TokenKind.QuestionDot, TokenKind_1.TokenKind.LeftSquareBracket)) {
                 expr = this.indexedGet(expr);
             }
             else if (this.match(TokenKind_1.TokenKind.Callfunc)) {
                 expr = this.callfunc(expr);
-                //store this callfunc expression in references
-                referenceCallExpression = expr;
             }
             else if (this.matchAny(TokenKind_1.TokenKind.Dot, TokenKind_1.TokenKind.QuestionDot)) {
                 if (this.match(TokenKind_1.TokenKind.LeftSquareBracket)) {
@@ -1785,19 +1911,24 @@ class Parser {
                 }
                 else {
                     let dot = this.previous();
-                    let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedPropertyNameAfterPeriod(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+                    let name = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedPropertyNameAfterPeriod(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+                    if (!name) {
+                        break;
+                    }
                     // force it into an identifier so the AST makes some sense
                     name.kind = TokenKind_1.TokenKind.Identifier;
-                    expr = new Expression_1.DottedGetExpression(expr, name, dot);
-                    this.addPropertyHints(name);
+                    expr = new Expression_1.DottedGetExpression({ obj: expr, name: name, dot: dot });
                 }
             }
             else if (this.checkAny(TokenKind_1.TokenKind.At, TokenKind_1.TokenKind.QuestionAt)) {
                 let dot = this.advance();
-                let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedAttributeNameAfterAtSymbol(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+                let name = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedAttributeNameAfterAtSymbol(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
                 // force it into an identifier so the AST makes some sense
                 name.kind = TokenKind_1.TokenKind.Identifier;
-                expr = new Expression_1.XmlAttributeGetExpression(expr, name, dot);
+                if (!name) {
+                    break;
+                }
+                expr = new Expression_1.XmlAttributeGetExpression({ obj: expr, name: name, at: dot });
                 //only allow a single `@` expression
                 break;
             }
@@ -1805,10 +1936,6 @@ 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) {
@@ -1821,68 +1948,109 @@ class Parser {
                     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());
+                try {
+                    args.push(this.expression());
+                }
+                catch (error) {
+                    this.rethrowNonDiagnosticError(error);
+                    // we were unable to get an expression, so don't continue
+                    break;
+                }
             } while (this.match(TokenKind_1.TokenKind.Comma));
         }
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
-        const closingParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), TokenKind_1.TokenKind.RightParen);
-        let expression = new Expression_1.CallExpression(callee, openingParen, closingParen, args, this.currentNamespaceName);
+        const closingParen = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), TokenKind_1.TokenKind.RightParen);
+        let expression = new Expression_1.CallExpression({
+            callee: callee,
+            openingParen: openingParen,
+            args: args,
+            closingParen: closingParen
+        });
         if (addToCallExpressionList) {
             this.callExpressions.push(expression);
         }
         return expression;
     }
     /**
-     * Tries to get the next token as a type
-     * Allows for built-in types (double, string, etc.) or namespaced custom types in Brighterscript mode
-     * Will  return a token of whatever is next to be parsed (unless `advanceIfUnknown` is false, in which case undefined will be returned instead
+     * Creates a TypeExpression, which wraps standard ASTNodes that represent a BscType
      */
     typeExpression() {
-        let typeToken;
-        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 identifier
-                const qualifiedType = this.getNamespacedVariableNameExpression();
-                typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
+        const changedTokens = [];
+        try {
+            let expr = this.getTypeExpressionPart(changedTokens);
+            while (this.options.mode === ParseMode.BrighterScript && this.matchAny(TokenKind_1.TokenKind.Or)) {
+                // If we're in Brighterscript mode, allow union types with "or" between types
+                // TODO: Handle Union types in parens? eg. "(string or integer)"
+                let operator = this.previous();
+                let right = this.getTypeExpressionPart(changedTokens);
+                if (right) {
+                    expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
+                }
+                else {
+                    break;
+                }
+            }
+            if (expr) {
+                return new Expression_1.TypeExpression({ expression: expr });
             }
-            catch (_a) {
-                //could not get an identifier - just get whatever's next
-                typeToken = this.advance();
+        }
+        catch (error) {
+            // Something went wrong - reset the kind to what it was previously
+            for (const changedToken of changedTokens) {
+                changedToken.token.kind = changedToken.oldKind;
             }
+            throw error;
+        }
+    }
+    /**
+     * Gets a single "part" of a type of a potential Union type
+     * Note: this does not NEED to be part of a union type, but the logic is the same
+     *
+     * @param changedTokens an array that is modified with any tokens that have been changed from their default kind to identifiers - eg. when a keyword is used as type
+     * @returns an expression that was successfully parsed
+     */
+    getTypeExpressionPart(changedTokens) {
+        let expr;
+        if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
+            // if this is just a type, just use directly
+            expr = new Expression_1.VariableExpression({ name: this.advance() });
         }
         else {
-            // just get whatever's next
-            typeToken = this.advance();
+            if (this.checkAny(...TokenKind_1.AllowedTypeIdentifiers)) {
+                // Since the next token is allowed as a type identifier, change the kind
+                let nextToken = this.peek();
+                changedTokens.push({ token: nextToken, oldKind: nextToken.kind });
+                nextToken.kind = TokenKind_1.TokenKind.Identifier;
+            }
+            expr = this.identifyingExpression(TokenKind_1.AllowedTypeIdentifiers);
         }
-        //TODO: to support InterfaceTypeLiterals - (eg. `{name as string; age as integer}`), check if "typeToken" is a curly bracket, and do something else
-        let typeExpr = new Expression_1.TypeExpression({ type: typeToken }, this.currentNamespaceName);
-        if (this.options.mode === ParseMode.BrighterScript) {
+        //Check if it has square brackets, thus making it an array
+        if (expr && this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
+            if (this.options.mode === ParseMode.BrightScript) {
+                // typed arrays not allowed in Brightscript
+                this.warnIfNotBrighterScriptMode('typed arrays');
+                return expr;
+            }
             // Check if it is an array - that is, if it has `[]` after the type
-            // eg. `string[]` or `SomeKlass[]` or `float[][][]`
+            // eg. `string[]` or `SomeKlass[]`
+            // This is while loop, so it supports multidimensional arrays (eg. integer[][])
             while (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
                 const leftBracket = this.advance();
                 if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
                     const rightBracket = this.advance();
-                    typeExpr = new Expression_1.ArrayTypeExpression([typeExpr], { leftBracket: leftBracket, rightBracket: rightBracket }, this.currentNamespaceName);
-                }
-                else {
-                    break;
+                    expr = new Expression_1.TypedArrayExpression({ innerType: expr, leftBracket: leftBracket, rightBracket: rightBracket });
                 }
             }
         }
-        return typeExpr;
+        return expr;
     }
     primary() {
         switch (true) {
             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());
+                return new Expression_1.LiteralExpression({ value: this.previous() });
             //capture source literals (LINE_NUM if brightscript, or a bunch of them if brighterscript)
             case this.matchAny(TokenKind_1.TokenKind.LineNumLiteral, ...(this.options.mode === ParseMode.BrightScript ? [] : TokenKind_1.BrighterScriptSourceLiterals)):
-                return new Expression_1.SourceLiteralExpression(this.previous());
+                return new Expression_1.SourceLiteralExpression({ value: this.previous() });
             //template string
             case this.check(TokenKind_1.TokenKind.BackTick):
                 return this.templateString(false);
@@ -1890,12 +2058,12 @@ class Parser {
             case this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedLocalIdentifiers) && this.checkNext(TokenKind_1.TokenKind.BackTick):
                 return this.templateString(true);
             case this.matchAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers):
-                return new Expression_1.VariableExpression(this.previous(), this.currentNamespaceName);
+                return new Expression_1.VariableExpression({ name: this.previous() });
             case this.match(TokenKind_1.TokenKind.LeftParen):
                 let left = this.previous();
                 let expr = this.expression();
                 let right = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftParenAfterExpression(), TokenKind_1.TokenKind.RightParen);
-                return new Expression_1.GroupingExpression({ left: left, right: right }, expr);
+                return new Expression_1.GroupingExpression({ leftParen: left, rightParen: right, expression: expr });
             case this.matchAny(TokenKind_1.TokenKind.LeftSquareBracket):
                 return this.arrayLiteral();
             case this.match(TokenKind_1.TokenKind.LeftCurlyBrace):
@@ -1904,13 +2072,13 @@ class Parser {
                 let token = Object.assign(this.previous(), {
                     kind: TokenKind_1.TokenKind.Identifier
                 });
-                return new Expression_1.VariableExpression(token, this.currentNamespaceName);
+                return new Expression_1.VariableExpression({ name: token });
             case this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub):
                 return this.anonymousFunction();
             case this.check(TokenKind_1.TokenKind.RegexLiteral):
                 return this.regexLiteralExpression();
             case this.check(TokenKind_1.TokenKind.Comment):
-                return new Statement_1.CommentStatement([this.advance()]);
+                return new Statement_1.CommentStatement({ comments: [this.advance()] });
             default:
                 //if we found an expected terminator, don't throw a diagnostic...just return undefined
                 if (this.checkAny(...this.peekGlobalTerminators())) {
@@ -1928,29 +2096,37 @@ class Parser {
         let openingSquare = this.previous();
         //add any comment found right after the opening square
         if (this.check(TokenKind_1.TokenKind.Comment)) {
-            elements.push(new Statement_1.CommentStatement([this.advance()]));
+            elements.push(new Statement_1.CommentStatement({ comments: [this.advance()] }));
         }
         while (this.match(TokenKind_1.TokenKind.Newline)) {
         }
+        let closingSquare;
         if (!this.match(TokenKind_1.TokenKind.RightSquareBracket)) {
-            elements.push(this.expression());
-            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(TokenKind_1.TokenKind.Newline)) {
-                }
-                if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
-                    break;
-                }
+            try {
                 elements.push(this.expression());
+                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({ comments: [comment] }));
+                    }
+                    while (this.match(TokenKind_1.TokenKind.Newline)) {
+                    }
+                    if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
+                        break;
+                    }
+                    elements.push(this.expression());
+                }
             }
-            this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftSquareBraceAfterArrayLiteral(), TokenKind_1.TokenKind.RightSquareBracket);
+            catch (error) {
+                this.rethrowNonDiagnosticError(error);
+            }
+            closingSquare = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftSquareBraceAfterArrayLiteral(), TokenKind_1.TokenKind.RightSquareBracket);
+        }
+        else {
+            closingSquare = this.previous();
         }
-        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);
+        return new Expression_1.ArrayLiteralExpression({ elements: elements, open: openingSquare, close: closingSquare });
     }
     aaLiteral() {
         let openingBrace = this.previous();
@@ -1976,51 +2152,66 @@ class Parser {
             return result;
         };
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        let closingBrace;
         if (!this.match(TokenKind_1.TokenKind.RightCurlyBrace)) {
             let lastAAMember;
-            if (this.check(TokenKind_1.TokenKind.Comment)) {
-                lastAAMember = null;
-                members.push(new Statement_1.CommentStatement([this.advance()]));
-            }
-            else {
-                let k = key();
-                let expr = this.expression();
-                lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr, getBscTypeFromExpression(expr, this.currentFunctionExpression));
-                members.push(lastAAMember);
-            }
-            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(TokenKind_1.TokenKind.Comma)) {
-                    lastAAMember.commaToken = this.previous();
-                }
-                //check for comment at the end of the current line
-                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]));
+            try {
+                if (this.check(TokenKind_1.TokenKind.Comment)) {
+                    lastAAMember = null;
+                    members.push(new Statement_1.CommentStatement({ comments: [this.advance()] }));
                 }
                 else {
-                    this.consumeStatementSeparators(true);
-                    //check for a comment on its own line
+                    let k = key();
+                    let expr = this.expression();
+                    lastAAMember = new Expression_1.AAMemberExpression({
+                        key: k.keyToken,
+                        colon: k.colonToken,
+                        value: expr
+                    });
+                    members.push(lastAAMember);
+                }
+                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(TokenKind_1.TokenKind.Comma)) {
+                        lastAAMember.tokens.comma = this.previous();
+                    }
+                    //check for comment at the end of the current line
                     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;
+                        members.push(new Statement_1.CommentStatement({ comments: [token] }));
                     }
-                    if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
-                        break;
+                    else {
+                        this.consumeStatementSeparators(true);
+                        //check for a comment on its own line
+                        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({ comments: [token] }));
+                            continue;
+                        }
+                        if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
+                            break;
+                        }
+                        let k = key();
+                        let expr = this.expression();
+                        lastAAMember = new Expression_1.AAMemberExpression({
+                            key: k.keyToken,
+                            colon: k.colonToken,
+                            value: expr
+                        });
+                        members.push(lastAAMember);
                     }
-                    let k = key();
-                    let expr = this.expression();
-                    lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr, getBscTypeFromExpression(expr, this.currentFunctionExpression));
-                    members.push(lastAAMember);
                 }
             }
-            this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), TokenKind_1.TokenKind.RightCurlyBrace);
+            catch (error) {
+                this.rethrowNonDiagnosticError(error);
+            }
+            closingBrace = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), TokenKind_1.TokenKind.RightCurlyBrace);
         }
-        let closingBrace = this.previous();
-        const aaExpr = new Expression_1.AALiteralExpression(members, openingBrace, closingBrace, this.currentFunctionExpression);
-        this.addPropertyHints(aaExpr);
+        else {
+            closingBrace = this.previous();
+        }
+        const aaExpr = new Expression_1.AALiteralExpression({ elements: members, open: openingBrace, close: closingBrace });
         return aaExpr;
     }
     /**
@@ -2035,7 +2226,7 @@ class Parser {
     }
     /**
      * Pop token if we encounter a token in the specified list
-     * @param tokenKinds
+     * @param tokenKinds a list of tokenKinds where any tokenKind in this list will result in a match
      */
     matchAny(...tokenKinds) {
         for (let tokenKind of tokenKinds) {
@@ -2048,7 +2239,7 @@ class Parser {
     }
     /**
      * If the next series of tokens matches the given set of tokens, pop them all
-     * @param tokenKinds
+     * @param tokenKinds a list of tokenKinds used to match the next set of tokens
      */
     matchSequence(...tokenKinds) {
         var _a;
@@ -2075,6 +2266,14 @@ class Parser {
             throw error;
         }
     }
+    /**
+     * Consume next token IF it matches the specified kind. Otherwise, do nothing and return undefined
+     */
+    consumeTokenIf(tokenKind) {
+        if (this.match(tokenKind)) {
+            return this.previous();
+        }
+    }
     consumeToken(tokenKind) {
         return this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(tokenKind), tokenKind);
     }
@@ -2121,6 +2320,11 @@ class Parser {
         var _a;
         return ((_a = this.previous()) === null || _a === void 0 ? void 0 : _a.kind) === tokenKind;
     }
+    /**
+     * Check that the next token kind is the expected kind
+     * @param tokenKind the expected next kind
+     * @returns true if the next tokenKind is the expected value
+     */
     check(tokenKind) {
         const nextKind = this.peek().kind;
         if (nextKind === TokenKind_1.TokenKind.Eof) {
@@ -2163,6 +2367,18 @@ class Parser {
     previous() {
         return this.tokens[this.current - 1];
     }
+    /**
+     * Sometimes we catch an error that is a diagnostic.
+     * If that's the case, we want to continue parsing.
+     * Otherwise, re-throw the error
+     *
+     * @param error error caught in a try/catch
+     */
+    rethrowNonDiagnosticError(error) {
+        if (!error.isDiagnostic) {
+            throw error;
+        }
+    }
     /**
      * Get the token that is {offset} indexes away from {this.current}
      * @param offset the number of index steps away from current index to fetch
@@ -2203,398 +2419,6 @@ class Parser {
             this.advance();
         }
     }
-    /**
-     * Get the token at the specified position
-     * @param position
-     */
-    getTokenAt(position) {
-        for (let token of this.tokens) {
-            if (util_1.util.rangeContains(token.range, position)) {
-                return token;
-            }
-        }
-    }
-    /**
-     * Get the token closest to the position. if no token is found, the previous token is returned
-     * @param position
-     * @param tokens
-     */
-    getClosestToken(position) {
-        let tokens = this.tokens;
-        for (let i = 0; i < tokens.length; i++) {
-            let token = tokens[i];
-            if (util_1.util.rangeContains(token.range, position)) {
-                return token;
-            }
-            //if the position less than this token range, then this position touches no token,
-            if (util_1.util.positionIsGreaterThanRange(position, token.range) === false) {
-                let t = tokens[i - 1];
-                //return the token or the first token
-                return t ? t : tokens[0];
-            }
-        }
-        //return the last token
-        return tokens[tokens.length - 1];
-    }
-    isPositionNextToTokenKind(position, tokenKind) {
-        const closestToken = this.getClosestToken(position);
-        const previousToken = this.getPreviousToken(closestToken);
-        const previousTokenKind = previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind;
-        //next to matched token
-        if (!closestToken || closestToken.kind === TokenKind_1.TokenKind.Eof) {
-            return false;
-        }
-        else if (closestToken.kind === tokenKind) {
-            return true;
-        }
-        else if (closestToken.kind === TokenKind_1.TokenKind.Newline || previousTokenKind === TokenKind_1.TokenKind.Newline) {
-            return false;
-            //next to an identifier, which is next to token kind
-        }
-        else if (closestToken.kind === TokenKind_1.TokenKind.Identifier && previousTokenKind === tokenKind) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    getTokenBefore(currentToken, tokenKind) {
-        const index = this.tokens.indexOf(currentToken);
-        for (let i = index - 1; i >= 0; i--) {
-            currentToken = this.tokens[i];
-            if (currentToken.kind === TokenKind_1.TokenKind.Newline) {
-                break;
-            }
-            else if (currentToken.kind === tokenKind) {
-                return currentToken;
-            }
-        }
-        return undefined;
-    }
-    tokenFollows(currentToken, tokenKind) {
-        const index = this.tokens.indexOf(currentToken);
-        if (index > 0) {
-            return this.tokens[index - 1].kind === tokenKind;
-        }
-        return false;
-    }
-    getTokensUntil(currentToken, tokenKind, direction = -1) {
-        let tokens = [];
-        for (let i = this.tokens.indexOf(currentToken); direction === -1 ? i >= 0 : i === this.tokens.length; i += direction) {
-            currentToken = this.tokens[i];
-            if (currentToken.kind === TokenKind_1.TokenKind.Newline || currentToken.kind === tokenKind) {
-                break;
-            }
-            tokens.push(currentToken);
-        }
-        return tokens;
-    }
-    getPreviousToken(token) {
-        let idx = this.tokens.indexOf(token);
-        return this.tokens[idx - 1];
-    }
-    getPreviousTokenFromIndex(idx) {
-        return { token: this.tokens[idx - 1], index: idx - 1 };
-    }
-    getPreviousTokenIgnoreNests(currentTokenIndex, leftBracketType, rightBracketType) {
-        let currentToken = this.tokens[currentTokenIndex];
-        let previousTokenResult;
-        function isRightBracket(token) {
-            return (token === null || token === void 0 ? void 0 : token.kind) === rightBracketType;
-        }
-        function isLeftBracket(token) {
-            return (token === null || token === void 0 ? void 0 : token.kind) === leftBracketType;
-        }
-        let lastTokenHadLeadingWhitespace = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.leadingWhitespace.length) > 0;
-        let lastTokenWasLeftBracket = false;
-        let bracketNestCount = 0;
-        let hasBrackets = false;
-        // check for nested function call
-        if (isRightBracket(currentToken)) {
-            bracketNestCount++;
-            hasBrackets = true;
-        }
-        while (currentToken && bracketNestCount > 0) {
-            previousTokenResult = this.getPreviousTokenFromIndex(currentTokenIndex);
-            currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
-            currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
-            lastTokenWasLeftBracket = false;
-            if (isRightBracket(currentToken)) {
-                bracketNestCount++;
-            }
-            while (isLeftBracket(currentToken)) {
-                bracketNestCount--;
-                lastTokenWasLeftBracket = true;
-                lastTokenHadLeadingWhitespace = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.leadingWhitespace.length) > 0;
-                previousTokenResult = this.getPreviousTokenFromIndex(currentTokenIndex);
-                currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
-                currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
-            }
-        }
-        const isLiteral = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.StringLiteral || (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.IntegerLiteral || (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.FloatLiteral || (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.Boolean;
-        // We will not be able to decipher the token type if it was in brackets
-        // e.g (someVar+otherVar).toStr() -- we don't bother trying to decipher what "(someVar+otherVar)" is
-        let isUnknown = isLiteral || (lastTokenWasLeftBracket && (lastTokenHadLeadingWhitespace || !this.isAcceptableChainToken(currentToken)));
-        const tokenWithIndex = { token: currentToken, index: currentTokenIndex, tokenTypeIsNotKnowable: isUnknown, hasBrackets: hasBrackets };
-        return tokenWithIndex;
-    }
-    /**
-     * Finds the previous token in a chain (e.g. 'm.obj.func(someFunc()).value'), skipping over any arguments of function calls
-     * If this function was called with the token at 'value' above, the previous identifier in the chain is 'func'
-     * @param currentTokenIndex token index to start from
-     * @param allowCurrent can the current token be the token that's the identifier?
-     * @returns the previous identifer
-     */
-    getPreviousTokenInChain(currentTokenIndex, allowCurrent = false) {
-        let currentToken = this.tokens[currentTokenIndex];
-        let previousTokenResult;
-        let usage = TokenUsage.Direct;
-        if (!allowCurrent) {
-            previousTokenResult = this.getPreviousTokenFromIndex(currentTokenIndex);
-            currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
-            currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
-        }
-        if ((currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.Dot || (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.QuestionDot) {
-            previousTokenResult = this.getPreviousTokenFromIndex(currentTokenIndex);
-            currentToken = previousTokenResult.token;
-            currentTokenIndex = previousTokenResult.index;
-        }
-        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) {
-            usage = TokenUsage.Call;
-        }
-        let tokenTypeIsNotKnowable = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.tokenTypeIsNotKnowable;
-        if (currentTokenIndex) {
-            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) {
-                usage = TokenUsage.ArrayReference;
-            }
-        }
-        tokenTypeIsNotKnowable = tokenTypeIsNotKnowable || (previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.tokenTypeIsNotKnowable);
-        if (tokenTypeIsNotKnowable || this.isAcceptableChainToken(currentToken)) {
-            // either we have a valid chain token, or we can't know what the token type is
-            return { token: currentToken, index: currentTokenIndex, tokenTypeIsNotKnowable: tokenTypeIsNotKnowable, usage: usage };
-        }
-        return undefined;
-    }
-    isAcceptableChainToken(currentToken, lastTokenHasWhitespace = false) {
-        if (!currentToken || lastTokenHasWhitespace) {
-            return false;
-        }
-        if (currentToken.kind === TokenKind_1.TokenKind.Identifier) {
-            return true;
-        }
-        if (currentToken.leadingWhitespace.length === 0) {
-            // start of the chain
-            return TokenKind_1.AllowedLocalIdentifiers.includes(currentToken.kind);
-        }
-        // not the start of the chain
-        return TokenKind_1.AllowedProperties.includes(currentToken.kind);
-    }
-    /**
-     * Builds up a chain of tokens, starting with the first in the chain, and ending with currentToken
-     * e.g. m.prop.method().field (with 'field' as currentToken) -> ["m", "prop", "method", "field"], with each element as a token
-     * @param currentToken the token that is the end of the chain
-     * @returns array of tokens
-     */
-    getTokenChain(currentToken) {
-        const tokenChain = [];
-        let currentTokenIndex = this.tokens.indexOf(currentToken);
-        let previousTokenResult;
-        let lastTokenHasWhitespace = false;
-        let includesUnknown = false;
-        previousTokenResult = this.getPreviousTokenInChain(currentTokenIndex, true);
-        currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
-        currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
-        if (this.isAcceptableChainToken(currentToken)) {
-            tokenChain.push(previousTokenResult);
-            lastTokenHasWhitespace = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.leadingWhitespace.length) > 0;
-        }
-        if (!lastTokenHasWhitespace) {
-            previousTokenResult = this.getPreviousTokenInChain(currentTokenIndex);
-            currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
-            currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
-            includesUnknown = !!(previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.tokenTypeIsNotKnowable);
-            while (!includesUnknown && this.isAcceptableChainToken(currentToken, lastTokenHasWhitespace)) {
-                tokenChain.push(previousTokenResult);
-                lastTokenHasWhitespace = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.leadingWhitespace.length) > 0;
-                if (!lastTokenHasWhitespace) {
-                    previousTokenResult = this.getPreviousTokenInChain(currentTokenIndex);
-                    currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
-                    currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
-                    includesUnknown = includesUnknown || (previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.tokenTypeIsNotKnowable);
-                }
-            }
-        }
-        tokenChain.reverse();
-        return { chain: tokenChain, includesUnknowableTokenType: !!includesUnknown };
-    }
-    /**
-     * References are found during the initial parse.
-     * However, sometimes plugins can modify the AST, requiring a full walk to re-compute all references.
-     * This does that walk.
-     */
-    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);
-            },
-            FieldStatement: s => {
-                if (s.initialValue) {
-                    this._references.expressions.add(s.initialValue);
-                }
-            },
-            InterfaceStatement: s => {
-                this._references.interfaceStatements.push(s);
-            },
-            NamespaceStatement: s => {
-                this._references.namespaceStatements.push(s);
-            },
-            FunctionStatement: s => {
-                this._references.functionStatements.push(s);
-            },
-            ImportStatement: s => {
-                this._references.importStatements.push(s);
-            },
-            LibraryStatement: s => {
-                this._references.libraryStatements.push(s);
-            },
-            FunctionExpression: (expression, parent) => {
-                if (!(0, reflection_1.isMethodStatement)(parent) && !(0, reflection_1.isInterfaceMethodStatement)(parent)) {
-                    this._references.functionExpressions.push(expression);
-                }
-            },
-            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);
-                    }
-                }
-            },
-            BinaryExpression: (e, parent) => {
-                //walk the chain of binary expressions and add each one to the list of expressions
-                const expressions = [e];
-                let expression;
-                while ((expression = expressions.pop())) {
-                    if ((0, reflection_1.isBinaryExpression)(expression)) {
-                        expressions.push(expression.left, expression.right);
-                    }
-                    else {
-                        this._references.expressions.add(expression);
-                    }
-                }
-            },
-            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);
-            },
-            ConstStatement: s => {
-                this._references.constStatements.push(s);
-            },
-            UnaryExpression: e => {
-                this._references.expressions.add(e);
-            },
-            IncrementStatement: e => {
-                this._references.expressions.add(e);
-            }
-        }), {
-            walkMode: visitors_1.WalkMode.visitAllRecursive
-        });
-    }
-    getContainingExpression(currentToken) {
-        return [...this.references.expressions].find((cs) => util_1.util.rangeContainsRange(cs.range, currentToken.range));
-    }
-    getContainingClass(currentToken) {
-        return this.references.classStatements.find((cs) => util_1.util.rangeContains(cs.range, currentToken.range.start));
-    }
-    getContainingAA(currentToken) {
-        return this.references.aaLiterals.find((aa) => util_1.util.rangeContains(aa.range, currentToken.range.start));
-    }
-    getContainingNamespace(currentToken) {
-        return this.references.namespaceStatements.find((cs) => util_1.util.rangeContains(cs.range, currentToken.range.start));
-    }
-    getContainingFunctionExpression(currentToken) {
-        return this.getContainingFunctionExpressionByPosition(currentToken.range.start);
-    }
-    getContainingFunctionExpressionByPosition(position) {
-        return this.references.functionExpressions.find((fe) => util_1.util.rangeContains(fe.range, position));
-    }
     dispose() {
     }
 }
@@ -2604,154 +2428,9 @@ var ParseMode;
     ParseMode["BrightScript"] = "BrightScript";
     ParseMode["BrighterScript"] = "BrighterScript";
 })(ParseMode = exports.ParseMode || (exports.ParseMode = {}));
-class References {
-    constructor() {
-        this.cache = new Cache_1.Cache();
-        this.assignmentStatements = [];
-        this.classStatements = [];
-        this.dottedSetStatements = [];
-        this.aaLiterals = [];
-        this.functionExpressions = [];
-        this.functionStatements = [];
-        this.interfaceStatements = [];
-        this.enumStatements = [];
-        this.constStatements = [];
-        /**
-         * 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.
-         *
-         * Example 3:
-         * `value = SomeEnum.value > 2 or SomeEnum.otherValue < 10` will result in 4 entries. `SomeEnum.value`, `2`, `SomeEnum.otherValue`, `10`
-         */
-        this.expressions = new Set();
-        this.importStatements = [];
-        this.libraryStatements = [];
-        this.namespaceStatements = [];
-        this.newExpressions = [];
-        this.propertyHints = {};
-    }
-    get classStatementLookup() {
-        if (!this._classStatementLookup) {
-            this._classStatementLookup = new Map();
-            for (const stmt of this.classStatements) {
-                this._classStatementLookup.set(stmt.getName(ParseMode.BrighterScript).toLowerCase(), stmt);
-            }
-        }
-        return this._classStatementLookup;
-    }
-    /**
-     * A map of function statements, indexed by fully-namespaced lower function name.
-     */
-    get functionStatementLookup() {
-        if (!this._functionStatementLookup) {
-            this._functionStatementLookup = new Map();
-            for (const stmt of this.functionStatements) {
-                this._functionStatementLookup.set(stmt.getName(ParseMode.BrighterScript).toLowerCase(), stmt);
-            }
-        }
-        return this._functionStatementLookup;
-    }
-    get interfaceStatementLookup() {
-        if (!this._interfaceStatementLookup) {
-            this._interfaceStatementLookup = new Map();
-            for (const stmt of this.interfaceStatements) {
-                this._interfaceStatementLookup.set(stmt.getName(ParseMode.BrighterScript).toLowerCase(), stmt);
-            }
-        }
-        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;
-        });
-    }
-    get constStatementLookup() {
-        return this.cache.getOrAdd('consts', () => {
-            const result = new Map();
-            for (const stmt of this.constStatements) {
-                result.set(stmt.fullName.toLowerCase(), stmt);
-            }
-            return result;
-        });
-    }
-}
-exports.References = References;
-var TokenUsage;
-(function (TokenUsage) {
-    TokenUsage[TokenUsage["Direct"] = 1] = "Direct";
-    TokenUsage[TokenUsage["Call"] = 2] = "Call";
-    TokenUsage[TokenUsage["ArrayReference"] = 3] = "ArrayReference";
-})(TokenUsage = exports.TokenUsage || (exports.TokenUsage = {}));
 class CancelStatementError extends Error {
     constructor() {
         super('CancelStatement');
     }
 }
-/**
- * Gets the type of an expression. If it can not be processed, will return DynamicType
- *
- * @param expression the Expression to process
- * @param functionExpression the wrapping function expression
- * @return the best guess type of that expression
- */
-function getBscTypeFromExpression(expression, functionExpression) {
-    try {
-        if ((0, reflection_1.isFunctionExpression)(expression)) {
-            return expression.getFunctionType();
-            //literal
-        }
-        else if ((0, reflection_1.isLiteralExpression)(expression)) {
-            return expression.type;
-            //Associative array literal
-        }
-        else if ((0, reflection_1.isAALiteralExpression)(expression)) {
-            return new ObjectType_1.ObjectType('object', expression.memberTable);
-            //Array literal
-        }
-        else if ((0, reflection_1.isArrayLiteralExpression)(expression)) {
-            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 (functionExpression) {
-            // These are more precise, and can't be determined without knowing the function expression you're in
-            if ((0, reflection_1.isNewExpression)(expression)) {
-                return (0, helpers_1.getTypeFromNewExpression)(expression, functionExpression);
-            }
-            else if ((0, reflection_1.isCallExpression)(expression)) {
-                return (0, helpers_1.getTypeFromCallExpression)(expression, functionExpression);
-            }
-            else if ((0, reflection_1.isVariableExpression)(expression)) {
-                return (0, helpers_1.getTypeFromVariableExpression)(expression, functionExpression);
-            }
-            else if ((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
-    }
-    //fallback to dynamic
-    return DynamicType_1.DynamicType.instance;
-}
-exports.getBscTypeFromExpression = getBscTypeFromExpression;
 //# sourceMappingURL=Parser.js.map