brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/parser/Parser.js

@@ -1,21 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeFromVariableExpression = exports.getTypeFromCallExpression = exports.getBscTypeFromExpression = exports.References = exports.ParseMode = exports.Parser = void 0;
-const lexer_1 = require("../lexer");
+exports.ParseMode = exports.Parser = void 0;
+const Token_1 = require("../lexer/Token");
+const Lexer_1 = require("../lexer/Lexer");
+const TokenKind_1 = require("../lexer/TokenKind");
 const Statement_1 = require("./Statement");
 const DiagnosticMessages_1 = require("../DiagnosticMessages");
 const util_1 = require("../util");
 const Expression_1 = require("./Expression");
-const Logger_1 = require("../Logger");
+const logging_1 = require("../logging");
 const reflection_1 = require("../astUtils/reflection");
-const visitors_1 = require("../astUtils/visitors");
 const creators_1 = require("../astUtils/creators");
-const DynamicType_1 = require("../types/DynamicType");
-const LazyType_1 = require("../types/LazyType");
-const SymbolTable_1 = require("../SymbolTable");
-const ObjectType_1 = require("../types/ObjectType");
-const CustomType_1 = require("../types/CustomType");
-const ArrayType_1 = require("../types/ArrayType");
+const semver = require("semver");
+const declarableTypesLower = TokenKind_1.DeclarableTypes.map(tokenKind => tokenKind.toLowerCase());
 class Parser {
     constructor() {
         /**
@@ -25,61 +22,36 @@ class Parser {
         /**
          * The list of statements for the parsed file
          */
-        this.ast = new Statement_1.Body([]);
-        this.symbolTable = new SymbolTable_1.SymbolTable();
-        this._references = new References();
+        this.ast = new Statement_1.Body({ statements: [] });
         this.globalTerminators = [];
         /**
          * An array of CallExpression for the current function body
          */
         this.callExpressions = [];
+        this.nestedInlineConditionalCount = 0;
     }
-    get statements() {
-        return this.ast.statements;
-    }
-    get currentSymbolTable() {
-        var _a, _b;
-        return (_b = (_a = this.currentFunctionExpression) === null || _a === void 0 ? void 0 : _a.symbolTable) !== null && _b !== void 0 ? _b : this.symbolTable;
+    get eofToken() {
+        var _a;
+        const lastToken = (_a = this.tokens) === null || _a === void 0 ? void 0 : _a[this.tokens.length - 1];
+        if ((lastToken === null || lastToken === void 0 ? void 0 : lastToken.kind) === TokenKind_1.TokenKind.Eof) {
+            return lastToken;
+        }
     }
     /**
-     * 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
+     * The top-level symbol table for the body of this file.
      */
-    get references() {
-        //build the references object if it's missing.
-        if (!this._references) {
-            this.findReferences();
-        }
-        return this._references;
+    get symbolTable() {
+        return this.ast.symbolTable;
     }
     /**
-     * Invalidates (clears) the references collection. This should be called anytime the AST has been manipulated.
+     * If line continuation is enabled, consumes all immediately following Newline tokens.
+     * Call this after matching a binary operator to allow the right-hand operand on the next line.
      */
-    invalidateReferences() {
-        this._references = undefined;
-    }
-    addPropertyHints(item) {
-        if (lexer_1.isToken(item)) {
-            const name = item.text;
-            this._references.propertyHints[name.toLowerCase()] = name;
-        }
-        else {
-            for (const member of item.elements) {
-                if (!reflection_1.isCommentStatement(member)) {
-                    const name = member.keyToken.text;
-                    if (!name.startsWith('"')) {
-                        this._references.propertyHints[name.toLowerCase()] = name;
-                    }
-                }
-            }
+    consumeNewlinesIfAllowed() {
+        if (this.allowLineContinuation) {
+            while (this.match(TokenKind_1.TokenKind.Newline)) { }
         }
     }
-    get currentNamespaceName() {
-        var _a;
-        return (_a = this.currentNamespace) === null || _a === void 0 ? void 0 : _a.nameExpression;
-    }
     /**
      * Get the currently active global terminators
      */
@@ -87,41 +59,53 @@ class Parser {
         var _a;
         return (_a = this.globalTerminators[this.globalTerminators.length - 1]) !== null && _a !== void 0 ? _a : [];
     }
+    /**
+     * Static wrapper around creating a new parser and parsing a list of tokens
+     */
     static parse(toParse, options) {
-        let tokens;
-        if (typeof toParse === 'string') {
-            tokens = lexer_1.Lexer.scan(toParse).tokens;
-        }
-        else {
-            tokens = toParse;
-        }
-        return new Parser().parse(tokens, options);
+        return new Parser().parse(toParse, options);
     }
     /**
      * Parses an array of `Token`s into an abstract syntax tree
      * @param toParse the array of tokens to parse. May not contain any whitespace tokens
      * @returns the same instance of the parser which contains the diagnostics and statements
      */
-    parse(tokens, options) {
+    parse(toParse, options) {
         var _a;
-        this.logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : new Logger_1.Logger();
+        this.logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : (0, logging_1.createLogger)();
+        options = this.sanitizeParseOptions(options);
+        this.options = options;
+        const coercedMinFirmwareVersion = semver.coerce(this.options.minFirmwareVersion);
+        this.allowLineContinuation = options.mode === ParseMode.BrighterScript || (!!coercedMinFirmwareVersion && semver.gte(coercedMinFirmwareVersion, Parser.LINE_CONTINUATION_MIN_FIRMWARE_VERSION));
+        let tokens;
+        if (typeof toParse === 'string') {
+            tokens = Lexer_1.Lexer.scan(toParse, {
+                trackLocations: options.trackLocations,
+                srcPath: options === null || options === void 0 ? void 0 : options.srcPath
+            }).tokens;
+        }
+        else {
+            tokens = toParse;
+        }
         this.tokens = tokens;
-        this.options = this.sanitizeParseOptions(options);
         this.allowedLocalIdentifiers = [
-            ...lexer_1.AllowedLocalIdentifiers,
+            ...TokenKind_1.AllowedLocalIdentifiers,
             //when in plain brightscript mode, the BrighterScript source literals can be used as regular variables
-            ...(this.options.mode === ParseMode.BrightScript ? lexer_1.BrighterScriptSourceLiterals : [])
+            ...(this.options.mode === ParseMode.BrightScript ? TokenKind_1.BrighterScriptSourceLiterals : [])
         ];
         this.current = 0;
         this.diagnostics = [];
         this.namespaceAndFunctionDepth = 0;
         this.pendingAnnotations = [];
         this.ast = this.body();
+        this.ast.bsConsts = options.bsConsts;
+        //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([]);
+        let body = new Statement_1.Body({ statements: [] });
         if (this.tokens.length > 0) {
             this.consumeStatementSeparators(true);
             try {
@@ -132,7 +116,7 @@ class Parser {
                     !this.checkAny(...this.peekGlobalTerminators())) {
                     let dec = this.declaration();
                     if (dec) {
-                        if (!reflection_1.isAnnotationExpression(dec)) {
+                        if (!(0, reflection_1.isAnnotationExpression)(dec)) {
                             this.consumePendingAnnotations(dec);
                             body.statements.push(dec);
                             //ensure statement separator
@@ -153,7 +137,13 @@ class Parser {
         return body;
     }
     sanitizeParseOptions(options) {
-        return Object.assign({ mode: 'brightscript' }, (options || {}));
+        var _a, _b;
+        options !== null && options !== void 0 ? options : (options = {
+            srcPath: undefined
+        });
+        (_a = options.mode) !== null && _a !== void 0 ? _a : (options.mode = ParseMode.BrightScript);
+        (_b = options.trackLocations) !== null && _b !== void 0 ? _b : (options.trackLocations = true);
+        return options;
     }
     /**
      * Determine if the parser is currently parsing tokens at the root level.
@@ -166,7 +156,7 @@ class Parser {
      */
     warnIfNotBrighterScriptMode(featureName) {
         if (this.options.mode !== ParseMode.BrighterScript) {
-            let diagnostic = Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles(featureName)), { range: this.peek().range });
+            let diagnostic = Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles(featureName)), { location: this.peek().location });
             this.diagnostics.push(diagnostic);
         }
     }
@@ -181,23 +171,32 @@ class Parser {
     }
     declaration() {
         try {
-            if (this.check(lexer_1.TokenKind.Class)) {
-                return this.classDeclaration();
+            if (this.checkAny(TokenKind_1.TokenKind.HashConst)) {
+                return this.conditionalCompileConstStatement();
+            }
+            if (this.checkAny(TokenKind_1.TokenKind.HashIf)) {
+                return this.conditionalCompileStatement();
+            }
+            if (this.checkAny(TokenKind_1.TokenKind.HashError)) {
+                return this.conditionalCompileErrorStatement();
             }
-            if (this.checkAny(lexer_1.TokenKind.Sub, lexer_1.TokenKind.Function)) {
+            if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
                 return this.functionDeclaration(false);
             }
             if (this.checkLibrary()) {
                 return this.libraryStatement();
             }
-            if (this.check(lexer_1.TokenKind.Namespace)) {
-                return this.namespaceStatement();
+            if (this.checkAlias()) {
+                return this.aliasStatement();
             }
-            if (this.check(lexer_1.TokenKind.At) && this.checkNext(lexer_1.TokenKind.Identifier)) {
-                return this.annotationExpression();
+            if (this.checkTypeStatement()) {
+                return this.typeStatement();
+            }
+            if (this.check(TokenKind_1.TokenKind.Const) && this.checkAnyNext(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+                return this.constDeclaration();
             }
-            if (this.check(lexer_1.TokenKind.Comment)) {
-                return this.commentStatement();
+            if (this.check(TokenKind_1.TokenKind.At) && this.checkNext(TokenKind_1.TokenKind.Identifier)) {
+                return this.annotationExpression();
             }
             //catch certain global terminators to prevent unnecessary lookahead (i.e. like `end namespace`, no need to continue)
             if (this.checkAny(...this.peekGlobalTerminators())) {
@@ -213,34 +212,265 @@ class Parser {
             this.synchronize();
         }
     }
+    /**
+     * Try to get an identifier. If not found, add diagnostic and return undefined
+     */
+    tryIdentifier(...additionalTokenKinds) {
+        const identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...additionalTokenKinds);
+        if (identifier) {
+            // force the name into an identifier so the AST makes some sense
+            identifier.kind = TokenKind_1.TokenKind.Identifier;
+            return identifier;
+        }
+    }
+    identifier(...additionalTokenKinds) {
+        const identifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...additionalTokenKinds);
+        // force the name into an identifier so the AST makes some sense
+        identifier.kind = TokenKind_1.TokenKind.Identifier;
+        return identifier;
+    }
+    enumMemberStatement() {
+        const name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+        let equalsToken;
+        let value;
+        //look for `= SOME_EXPRESSION`
+        if (this.check(TokenKind_1.TokenKind.Equal)) {
+            equalsToken = this.advance();
+            value = this.expression();
+        }
+        const statement = new Statement_1.EnumMemberStatement({ name: name, equals: equalsToken, value: value });
+        return statement;
+    }
+    /**
+     * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration`
+     */
+    interfaceFieldStatement(optionalKeyword) {
+        const name = this.identifier(...TokenKind_1.AllowedProperties);
+        let asToken;
+        let typeExpression;
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            [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.expectedIdentifier(asToken.text)), { location: asToken.location }));
+                }
+                //consume the statement separator
+                this.consumeStatementSeparators();
+            }
+            else if (!this.checkAny(TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.LeftCurlyBrace, TokenKind_1.TokenKind.LeftParen, ...TokenKind_1.DeclarableTypes, ...TokenKind_1.AllowedTypeIdentifiers)) {
+                if (!ignoreDiagnostics) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(asToken.text)), { location: asToken.location }));
+                }
+            }
+            else {
+                typeExpression = this.typeExpression();
+            }
+        }
+        if (this.checkAny(TokenKind_1.TokenKind.And, TokenKind_1.TokenKind.Or)) {
+            this.warnIfNotBrighterScriptMode('custom types');
+        }
+        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)), { location: this.peek().location }));
+                }
+                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);
+        const nameToken = this.identifier(...this.allowedLocalIdentifiers);
+        let extendsToken;
+        let parentInterfaceName;
+        if (this.peek().text.toLowerCase() === 'extends') {
+            extendsToken = this.advance();
+            if (this.checkEndOfStatement()) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(extendsToken.text)), { location: extendsToken.location }));
+            }
+            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.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.checkAnyNext(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+                    decl = this.interfaceMethodStatement(optionalKeyword);
+                }
+                if (decl) {
+                    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
+                this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
+            }
+            //ensure statement separator
+            this.consumeStatementSeparators();
+        }
+        //consume the final `end interface` token
+        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 enumToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
+        const nameToken = this.tryIdentifier(...this.allowedLocalIdentifiers);
+        this.warnIfNotBrighterScriptMode('enum declarations');
+        const parentAnnotations = this.enterAnnotationBlock();
+        this.consumeStatementSeparators();
+        const body = [];
+        //gather up all members
+        while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
+            try {
+                let decl;
+                //collect leading annotations
+                if (this.check(TokenKind_1.TokenKind.At)) {
+                    this.annotationExpression();
+                }
+                //members
+                if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+                    decl = this.enumMemberStatement();
+                }
+                if (decl) {
+                    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
+                this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
+            }
+            //ensure statement separator
+            this.consumeStatementSeparators();
+            //break out of this loop if we encountered the `EndEnum` token
+            if (this.check(TokenKind_1.TokenKind.EndEnum)) {
+                break;
+            }
+        }
+        //consume the final `end interface` token
+        const endEnumToken = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
+        const result = new Statement_1.EnumStatement({
+            enum: enumToken,
+            name: nameToken,
+            body: body,
+            endEnum: endEnumToken
+        });
+        this.exitAnnotationBlock(parentAnnotations);
+        return result;
+    }
     /**
      * A BrighterScript class declaration
      */
     classDeclaration() {
         this.warnIfNotBrighterScriptMode('class declarations');
         const parentAnnotations = this.enterAnnotationBlock();
-        let classKeyword = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassKeyword(), lexer_1.TokenKind.Class);
+        let classKeyword = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Class), TokenKind_1.TokenKind.Class);
         let extendsKeyword;
         let parentClassName;
         //get the class name
-        let className = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('class'), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+        let className = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('class'), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
         //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.expectedIdentifier(extendsKeyword.text)), { location: extendsKeyword.location }));
+            }
+            else {
+                parentClassName = this.typeExpression();
+            }
         }
         //ensure statement separator
         this.consumeStatementSeparators();
         //gather up all class members (Fields, Methods)
         let body = [];
-        while (this.checkAny(lexer_1.TokenKind.Public, lexer_1.TokenKind.Protected, lexer_1.TokenKind.Private, lexer_1.TokenKind.Function, lexer_1.TokenKind.Sub, lexer_1.TokenKind.Comment, lexer_1.TokenKind.Identifier, lexer_1.TokenKind.At, ...lexer_1.AllowedProperties)) {
+        while (this.checkAny(TokenKind_1.TokenKind.Public, TokenKind_1.TokenKind.Protected, TokenKind_1.TokenKind.Private, TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
             try {
                 let decl;
                 let accessModifier;
-                if (this.check(lexer_1.TokenKind.At)) {
+                if (this.check(TokenKind_1.TokenKind.At)) {
                     this.annotationExpression();
                 }
-                if (this.checkAny(lexer_1.TokenKind.Public, lexer_1.TokenKind.Protected, lexer_1.TokenKind.Private)) {
+                if (this.checkAny(TokenKind_1.TokenKind.Public, TokenKind_1.TokenKind.Protected, TokenKind_1.TokenKind.Private)) {
                     //use actual access modifier
                     accessModifier = this.advance();
                 }
@@ -249,29 +479,26 @@ class Parser {
                     overrideKeyword = this.advance();
                 }
                 //methods (function/sub keyword OR identifier followed by opening paren)
-                if (this.checkAny(lexer_1.TokenKind.Function, lexer_1.TokenKind.Sub) || (this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties) && this.checkNext(lexer_1.TokenKind.LeftParen))) {
+                if (this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub) || (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties) && this.checkNext(TokenKind_1.TokenKind.LeftParen))) {
                     const funcDeclaration = this.functionDeclaration(false, false);
-                    //remove this function from the lists because it's not a callable
-                    const functionStatement = this._references.functionStatements.pop();
                     //if we have an overrides keyword AND this method is called 'new', that's not allowed
-                    if (overrideKeyword && funcDeclaration.name.text.toLowerCase() === 'new') {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseOverrideKeywordOnConstructorFunction()), { range: overrideKeyword.range }));
+                    if (overrideKeyword && funcDeclaration.tokens.name.text.toLowerCase() === 'new') {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseOverrideKeywordOnConstructorFunction()), { location: overrideKeyword.location }));
                     }
-                    decl = new Statement_1.ClassMethodStatement(accessModifier, funcDeclaration.name, funcDeclaration.func, overrideKeyword);
-                    //refer to this statement as parent of the expression
-                    functionStatement.func.functionStatement = decl;
+                    decl = new Statement_1.MethodStatement({
+                        modifiers: accessModifier,
+                        name: funcDeclaration.tokens.name,
+                        func: funcDeclaration.func,
+                        override: overrideKeyword
+                    });
                     //fields
                 }
-                else if (this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties)) {
-                    decl = this.classFieldDeclaration(accessModifier);
+                else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+                    decl = this.fieldDeclaration(accessModifier);
                     //class fields cannot be overridden
                     if (overrideKeyword) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.classFieldCannotBeOverridden()), { range: overrideKeyword.range }));
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.classFieldCannotBeOverridden()), { location: overrideKeyword.location }));
                     }
-                    //comments
-                }
-                else if (this.check(lexer_1.TokenKind.Comment)) {
-                    decl = this.commentStatement();
                 }
                 if (decl) {
                     this.consumePendingAnnotations(decl);
@@ -280,166 +507,169 @@ class Parser {
             }
             catch (e) {
                 //throw out any failed members and move on to the next line
-                this.flagUntil(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Eof);
+                this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
             }
             //ensure statement separator
             this.consumeStatementSeparators();
         }
         let endingKeyword = this.advance();
-        if (endingKeyword.kind !== lexer_1.TokenKind.EndClass) {
-            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._references.classStatements.push(result);
+        if (endingKeyword.kind !== TokenKind_1.TokenKind.EndClass) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('class')), { location: endingKeyword.location }));
+        }
+        const result = new Statement_1.ClassStatement({
+            class: classKeyword,
+            name: className,
+            body: body,
+            endClass: endingKeyword,
+            extends: extendsKeyword,
+            parentClassName: parentClassName
+        });
         this.exitAnnotationBlock(parentAnnotations);
         return result;
     }
-    classFieldDeclaration(accessModifier) {
-        let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+    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.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         let asToken;
-        let fieldType;
+        let fieldTypeExpression;
         //look for `as SOME_TYPE`
-        if (this.check(lexer_1.TokenKind.As)) {
-            asToken = this.advance();
-            fieldType = this.typeToken();
-            //no field type specified
-            if (!util_1.util.tokenToBscType(fieldType)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedValidTypeToFollowAsKeyword()), { range: this.peek().range }));
-            }
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            [asToken, fieldTypeExpression] = this.consumeAsTokenAndTypeExpression();
         }
         let initialValue;
         let equal;
         //if there is a field initializer
-        if (this.check(lexer_1.TokenKind.Equal)) {
+        if (this.check(TokenKind_1.TokenKind.Equal)) {
             equal = this.advance();
             initialValue = this.expression();
         }
-        return new Statement_1.ClassFieldStatement(accessModifier, name, asToken, fieldType, equal, initialValue);
+        return new Statement_1.FieldStatement({
+            accessModifier: accessModifier,
+            name: name,
+            as: asToken,
+            typeExpression: fieldTypeExpression,
+            equals: equal,
+            initialValue: initialValue,
+            optional: optionalKeyword
+        });
     }
-    functionDeclaration(isAnonymous, checkIdentifier = true) {
-        var _a, _b, _c, _d;
+    functionDeclaration(isAnonymous, checkIdentifier = true, onlyCallableAsMember = false) {
         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 functionType;
-            if (this.checkAny(lexer_1.TokenKind.Sub, lexer_1.TokenKind.Function)) {
+            if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
                 functionType = this.advance();
             }
             else {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingCallableKeyword()), { range: this.peek().range }));
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingCallableKeyword()), { location: this.peek().location }));
+                //TODO we should probably eliminate this entirely, since it's not present in the source code
                 functionType = {
                     isReserved: true,
-                    kind: lexer_1.TokenKind.Function,
+                    kind: TokenKind_1.TokenKind.Function,
                     text: 'function',
                     //zero-length location means derived
-                    range: {
-                        start: this.peek().range.start,
-                        end: this.peek().range.start
-                    },
-                    leadingWhitespace: ''
+                    location: this.peek().location,
+                    leadingWhitespace: '',
+                    leadingTrivia: []
                 };
             }
-            let isSub = (functionType === null || functionType === void 0 ? void 0 : functionType.kind) === lexer_1.TokenKind.Sub;
+            let isSub = (functionType === null || functionType === void 0 ? void 0 : functionType.kind) === TokenKind_1.TokenKind.Sub;
             let functionTypeText = isSub ? 'sub' : 'function';
             let name;
             let leftParen;
             if (isAnonymous) {
-                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallable(functionTypeText), lexer_1.TokenKind.LeftParen);
+                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken('('), TokenKind_1.TokenKind.LeftParen);
             }
             else {
-                name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedNameAfterCallableKeyword(functionTypeText), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
-                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallableName(functionTypeText), lexer_1.TokenKind.LeftParen);
+                name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(functionTypeText), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken('('), 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(functionTypeText, name.text, lastChar)), { range: name.range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidIdentifier(name.text, lastChar)), { location: name.location }));
                 }
                 //flag functions with keywords for names (only for standard functions)
-                if (checkIdentifier && lexer_1.DisallowedFunctionIdentifiersText.has(name.text.toLowerCase())) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(name.text)), { range: name.range }));
+                if (checkIdentifier && TokenKind_1.DisallowedFunctionIdentifiersText.has(name.text.toLowerCase())) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(name.text)), { location: name.location }));
                 }
             }
             let params = [];
             let asToken;
-            let typeToken;
-            if (!this.check(lexer_1.TokenKind.RightParen)) {
+            let typeExpression;
+            if (!this.check(TokenKind_1.TokenKind.RightParen)) {
                 do {
-                    if (params.length >= Expression_1.CallExpression.MaximumArguments) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableParameters(params.length, Expression_1.CallExpression.MaximumArguments)), { range: this.peek().range }));
-                    }
                     params.push(this.functionParameter());
-                } while (this.match(lexer_1.TokenKind.Comma));
+                } while (this.match(TokenKind_1.TokenKind.Comma));
             }
-            let rightParen = this.advance();
-            if (this.check(lexer_1.TokenKind.As)) {
-                asToken = this.advance();
-                typeToken = this.typeToken();
-                if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType((_a = typeToken.text) !== null && _a !== void 0 ? _a : '')), { range: typeToken.range }));
-                }
+            let rightParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(leftParen.text, 'function parameter list'), TokenKind_1.TokenKind.RightParen);
+            if (this.check(TokenKind_1.TokenKind.As)) {
+                [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)), { location: param.location }));
                 }
                 return haveFoundOptional || !!param.defaultValue;
             }, false);
             this.consumeStatementSeparators(true);
-            let func = new Expression_1.FunctionExpression(params, undefined, //body
-            functionType, undefined, //ending keyword
-            leftParen, rightParen, asToken, typeToken, //return type
-            this.currentFunctionExpression, this.currentNamespaceName, (_c = (_b = this.currentNamespace) === null || _b === void 0 ? void 0 : _b.symbolTable) !== null && _c !== void 0 ? _c : this.symbolTable);
-            //if there is a parent function, register this function with the parent
-            if (this.currentFunctionExpression) {
-                this.currentFunctionExpression.childFunctionExpressions.push(func);
-            }
-            // add the function to the relevant symbol tables
-            if (!isAnonymous) {
-                const funcType = func.getFunctionType();
-                funcType.setName(name.text);
-                // add the function as declared to the current namespace's table
-                (_d = this.currentNamespace) === null || _d === void 0 ? void 0 : _d.symbolTable.addSymbol(name.text, name.range, funcType);
-                let fullyQualifiedName = name.text;
-                if (this.currentNamespaceName) {
-                    // add the "namespaced" name of this function to the parent symbol table
-                    fullyQualifiedName = this.currentNamespaceName.getName(ParseMode.BrighterScript) + '.' + name.text;
-                }
-                this.currentSymbolTable.addSymbol(fullyQualifiedName, name.range, funcType);
-            }
-            this._references.functionExpressions.push(func);
-            let previousFunctionExpression = this.currentFunctionExpression;
-            this.currentFunctionExpression = func;
-            //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(functionTypeText)), { range: this.peek().range }));
-                throw this.lastDiagnosticAsError();
-            }
+            //support ending the function with `end sub` OR `end function`
+            let body = this.block();
+            //if the parser was unable to produce a block, make an empty one so the AST makes some sense...
             // consume 'end sub' or 'end function'
-            func.end = this.advance();
-            let expectedEndKind = isSub ? lexer_1.TokenKind.EndSub : lexer_1.TokenKind.EndFunction;
+            const 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.end.kind !== expectedEndKind) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndCallableKeyword(functionTypeText, func.end.text)), { range: this.peek().range }));
+            if (endFunctionType.kind !== expectedEndKind) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.closingKeywordMismatch(functionTypeText, endFunctionType.text)), { location: endFunctionType.location }));
             }
-            func.callExpressions = this.callExpressions;
+            if (!body) {
+                body = new Statement_1.Block({ statements: [] });
+            }
+            let func = new Expression_1.FunctionExpression({
+                parameters: params,
+                body: body,
+                functionType: functionType,
+                endFunctionType: endFunctionType,
+                leftParen: leftParen,
+                rightParen: rightParen,
+                as: asToken,
+                returnTypeExpression: typeExpression
+            });
             if (isAnonymous) {
                 return func;
             }
             else {
-                let result = new Statement_1.FunctionStatement(name, func, this.currentNamespaceName);
-                func.functionStatement = result;
-                this._references.functionStatements.push(result);
+                let result = new Statement_1.FunctionStatement({ name: name, func: func });
                 return result;
             }
         }
@@ -449,77 +679,78 @@ class Parser {
             this.callExpressions = previousCallExpressions;
         }
     }
-    identifier() {
-        const identifier = this.advance();
-        // force the name into an identifier so the AST makes some sense
-        identifier.kind = lexer_1.TokenKind.Identifier;
-        return identifier;
-    }
     functionParameter() {
-        if (!this.checkAny(lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedParameterNameButFound(this.peek().text)), { range: this.peek().range }));
+        if (!this.checkAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedParameterNameButFound(this.peek().text)), { location: this.peek().location }));
             throw this.lastDiagnosticAsError();
         }
-        const name = this.identifier();
-        let typeToken;
+        let name = this.advance();
+        // force the name into an identifier so the AST makes some sense
+        name.kind = TokenKind_1.TokenKind.Identifier;
+        //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)), { location: name.location }));
+        }
+        let typeExpression;
         let defaultValue;
-        let equalsToken;
+        let equalToken;
         // parse argument default value
-        if (this.match(lexer_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(lexer_1.TokenKind.As)) {
-            asToken = this.advance();
-            typeToken = this.typeToken();
-            if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
-                throw this.lastDiagnosticAsError();
-            }
-        }
-        let type;
-        if (typeToken) {
-            type = util_1.util.tokenToBscType(typeToken);
-        }
-        else if (defaultValue) {
-            type = getBscTypeFromExpression(defaultValue, this.currentFunctionExpression);
-        }
-        else {
-            type = new DynamicType_1.DynamicType();
-        }
-        return new Expression_1.FunctionParameterExpression(name, type, equalsToken, defaultValue, asToken, typeToken, this.currentNamespaceName);
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+        }
+        return new Expression_1.FunctionParameterExpression({
+            name: name,
+            equals: equalToken,
+            defaultValue: defaultValue,
+            as: asToken,
+            typeExpression: typeExpression
+        });
     }
-    assignment() {
-        let name = this.identifier();
+    assignment(allowTypedAssignment = false) {
+        let name = this.advance();
         //add diagnostic if name is a reserved word that cannot be used as an identifier
-        if (lexer_1.DisallowedLocalIdentifiersText.has(name.text.toLowerCase())) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(name.text)), { range: name.range }));
+        if (TokenKind_1.DisallowedLocalIdentifiersText.has(name.text.toLowerCase())) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(name.text)), { location: name.location }));
         }
-        let operator = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOperatorAfterIdentifier(lexer_1.AssignmentOperators, name.text), ...lexer_1.AssignmentOperators);
-        let value = this.expression();
-        let result;
-        if (operator.kind === lexer_1.TokenKind.Equal) {
-            result = new Statement_1.AssignmentStatement(name, operator, value, this.currentFunctionExpression);
-        }
-        else {
-            result = new Statement_1.AssignmentStatement(name, operator, new Expression_1.BinaryExpression(new Expression_1.VariableExpression(name, this.currentNamespaceName), operator, value), this.currentFunctionExpression);
+        let asToken;
+        let typeExpression;
+        if (allowTypedAssignment) {
+            //look for `as SOME_TYPE`
+            if (this.check(TokenKind_1.TokenKind.As)) {
+                this.warnIfNotBrighterScriptMode('typed assignment');
+                [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+            }
         }
-        this._references.assignmentStatements.push(result);
-        const assignmentType = getBscTypeFromExpression(result.value, this.currentFunctionExpression);
-        this.currentSymbolTable.addSymbol(name.text, name.range, assignmentType);
+        let operator = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOperator([TokenKind_1.TokenKind.Equal], name.text), ...[TokenKind_1.TokenKind.Equal]);
+        let value = this.expression();
+        let result = new Statement_1.AssignmentStatement({ equals: operator, name: name, value: value, as: asToken, typeExpression: typeExpression });
+        return result;
+    }
+    augmentedAssignment() {
+        let item = this.expression();
+        let operator = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(...TokenKind_1.CompoundAssignmentOperators), ...TokenKind_1.CompoundAssignmentOperators);
+        let value = this.expression();
+        let result = new Statement_1.AugmentedAssignmentStatement({
+            item: item,
+            operator: operator,
+            value: value
+        });
         return result;
     }
     checkLibrary() {
-        let isLibraryToken = this.check(lexer_1.TokenKind.Library);
+        let isLibraryToken = this.check(TokenKind_1.TokenKind.Library);
         //if we are at the top level, any line that starts with "library" should be considered a library statement
         if (this.isAtRootLevel() && isLibraryToken) {
             return true;
             //not at root level, library statements are all invalid here, but try to detect if the tokens look
             //like a library statement (and let the libraryStatement function handle emitting the diagnostics)
         }
-        else if (isLibraryToken && this.checkNext(lexer_1.TokenKind.StringLiteral)) {
+        else if (isLibraryToken && this.checkNext(TokenKind_1.TokenKind.StringLiteral)) {
             return true;
             //definitely not a library statement
         }
@@ -527,58 +758,100 @@ class Parser {
             return false;
         }
     }
+    checkAlias() {
+        let isAliasToken = this.check(TokenKind_1.TokenKind.Alias);
+        //if we are at the top level, any line that starts with "alias" should be considered a alias statement
+        if (this.isAtRootLevel() && isAliasToken) {
+            return true;
+            //not at root level, alias statements are all invalid here, but try to detect if the tokens look
+            //like a alias statement (and let the alias function handle emitting the diagnostics)
+        }
+        else if (isAliasToken && this.checkNext(TokenKind_1.TokenKind.Identifier)) {
+            return true;
+            //definitely not a alias statement
+        }
+        else {
+            return false;
+        }
+    }
+    checkTypeStatement() {
+        let isTypeToken = this.check(TokenKind_1.TokenKind.Type);
+        //if we are at the top level, any line that starts with "type" should be considered a type statement
+        if (this.isAtRootLevel() && isTypeToken) {
+            return true;
+            //not at root level, type statements are all invalid here, but try to detect if the tokens look
+            //like a type statement (and let the type function handle emitting the diagnostics)
+        }
+        else if (isTypeToken && this.checkNext(TokenKind_1.TokenKind.Identifier)) {
+            return true;
+            //definitely not a type statement
+        }
+        else {
+            return false;
+        }
+    }
     statement() {
         if (this.checkLibrary()) {
             return this.libraryStatement();
         }
-        if (this.check(lexer_1.TokenKind.Import)) {
+        if (this.check(TokenKind_1.TokenKind.Import)) {
             return this.importStatement();
         }
-        if (this.check(lexer_1.TokenKind.Stop)) {
+        if (this.check(TokenKind_1.TokenKind.Typecast) && this.checkAnyNext(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+            return this.typecastStatement();
+        }
+        if (this.checkAlias()) {
+            return this.aliasStatement();
+        }
+        if (this.checkTypeStatement()) {
+            return this.typeStatement();
+        }
+        if (this.check(TokenKind_1.TokenKind.Stop)) {
             return this.stopStatement();
         }
-        if (this.check(lexer_1.TokenKind.If)) {
+        if (this.check(TokenKind_1.TokenKind.If)) {
             return this.ifStatement();
         }
         //`try` must be followed by a block, otherwise it could be a local variable
-        if (this.check(lexer_1.TokenKind.Try) && this.checkAnyNext(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Comment)) {
+        if (this.check(TokenKind_1.TokenKind.Try) && this.checkAnyNext(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
             return this.tryCatchStatement();
         }
-        if (this.check(lexer_1.TokenKind.Throw)) {
+        if (this.check(TokenKind_1.TokenKind.Throw)) {
             return this.throwStatement();
         }
-        if (this.checkAny(lexer_1.TokenKind.Print, lexer_1.TokenKind.Question)) {
+        if (this.checkAny(TokenKind_1.TokenKind.Print, TokenKind_1.TokenKind.Question)) {
             return this.printStatement();
         }
-        if (this.check(lexer_1.TokenKind.Dim)) {
+        if (this.check(TokenKind_1.TokenKind.Dim)) {
             return this.dimStatement();
         }
-        if (this.check(lexer_1.TokenKind.While)) {
+        if (this.check(TokenKind_1.TokenKind.While)) {
             return this.whileStatement();
         }
-        if (this.check(lexer_1.TokenKind.ExitWhile)) {
-            return this.exitWhile();
+        if (this.checkAny(TokenKind_1.TokenKind.Exit, TokenKind_1.TokenKind.ExitWhile)) {
+            return this.exitStatement();
         }
-        if (this.check(lexer_1.TokenKind.For)) {
+        if (this.check(TokenKind_1.TokenKind.For)) {
             return this.forStatement();
         }
-        if (this.check(lexer_1.TokenKind.ForEach)) {
+        if (this.check(TokenKind_1.TokenKind.ForEach)) {
             return this.forEachStatement();
         }
-        if (this.check(lexer_1.TokenKind.ExitFor)) {
-            return this.exitFor();
-        }
-        if (this.check(lexer_1.TokenKind.End)) {
+        if (this.check(TokenKind_1.TokenKind.End)) {
             return this.endStatement();
         }
-        if (this.match(lexer_1.TokenKind.Return)) {
+        if (this.match(TokenKind_1.TokenKind.Return)) {
             return this.returnStatement();
         }
-        if (this.check(lexer_1.TokenKind.Goto)) {
+        if (this.check(TokenKind_1.TokenKind.Goto)) {
             return this.gotoStatement();
         }
+        //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(lexer_1.TokenKind.Identifier) && this.checkNext(lexer_1.TokenKind.Colon) && this.checkPrevious(lexer_1.TokenKind.Newline)) {
+        if (this.check(TokenKind_1.TokenKind.Identifier) && this.checkNext(TokenKind_1.TokenKind.Colon) && this.checkPrevious(TokenKind_1.TokenKind.Newline)) {
             try {
                 return this.labelStatement();
             }
@@ -592,35 +865,105 @@ class Parser {
         // BrightScript is like python, in that variables can be declared without a `var`,
         // `let`, (...) keyword. As such, we must check the token *after* an identifier to figure
         // out what to do with it.
-        if (this.checkAny(lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers) &&
-            this.checkAnyNext(...lexer_1.AssignmentOperators)) {
-            return this.assignment();
+        if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+            if (this.checkAnyNext(...TokenKind_1.AssignmentOperators)) {
+                if (this.checkAnyNext(...TokenKind_1.CompoundAssignmentOperators)) {
+                    return this.augmentedAssignment();
+                }
+                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(true);
+                }
+            }
+        }
+        //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)) {
+            return this.interfaceDeclaration();
+        }
+        if (this.check(TokenKind_1.TokenKind.Class)) {
+            return this.classDeclaration();
+        }
+        if (this.check(TokenKind_1.TokenKind.Namespace)) {
+            return this.namespaceStatement();
+        }
+        if (this.check(TokenKind_1.TokenKind.Enum)) {
+            return this.enumDeclaration();
         }
         // TODO: support multi-statements
         return this.setStatement();
     }
     whileStatement() {
+        var _a, _b;
         const whileKeyword = this.advance();
         const condition = this.expression();
         this.consumeStatementSeparators();
-        const whileBlock = this.block(lexer_1.TokenKind.EndWhile);
+        const whileBlock = this.block(TokenKind_1.TokenKind.EndWhile, TokenKind_1.TokenKind.Next);
         let endWhile;
-        if (!whileBlock || this.peek().kind !== lexer_1.TokenKind.EndWhile) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('while')), { range: this.peek().range }));
+        if (whileBlock && this.peek().kind === TokenKind_1.TokenKind.EndWhile) {
+            endWhile = this.advance();
+        }
+        else if (whileBlock && this.peek().kind === TokenKind_1.TokenKind.Next) {
+            //recover: a stray `next` is a common mistake when the user means `end while`.
+            //emit a targeted diagnostic and consume the `next` so the rest of the file parses cleanly.
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndingToken(['end while'], 'next')), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
+            endWhile = this.advance();
+        }
+        else {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('while')), { location: (_b = this.peek()) === null || _b === void 0 ? void 0 : _b.location }));
             if (!whileBlock) {
                 throw this.lastDiagnosticAsError();
             }
         }
-        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();
-        return new Statement_1.ExitWhileStatement({ exitWhile: keyword });
+    exitStatement() {
+        var _a;
+        let exitToken = this.advance();
+        if (exitToken.kind === TokenKind_1.TokenKind.ExitWhile) {
+            // `exitwhile` is allowed in code, and means `exit while`
+            // use an ExitStatement that is nicer to work with by breaking the `exit` and `while` tokens apart
+            const exitText = exitToken.text.substring(0, 4);
+            const whileText = exitToken.text.substring(4);
+            const originalRange = (_a = exitToken.location) === null || _a === void 0 ? void 0 : _a.range;
+            const originalStart = originalRange === null || originalRange === void 0 ? void 0 : originalRange.start;
+            const exitRange = util_1.util.createRange(originalStart.line, originalStart.character, originalStart.line, originalStart.character + 4);
+            const whileRange = util_1.util.createRange(originalStart.line, originalStart.character + 4, originalStart.line, originalStart.character + exitToken.text.length);
+            exitToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Exit, exitText, util_1.util.createLocationFromRange(exitToken.location.uri, exitRange));
+            this.tokens[this.current - 1] = exitToken;
+            const newLoopToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.While, whileText, util_1.util.createLocationFromRange(exitToken.location.uri, whileRange));
+            this.tokens.splice(this.current, 0, newLoopToken);
+        }
+        const loopTypeToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.While, TokenKind_1.TokenKind.For), TokenKind_1.TokenKind.While, TokenKind_1.TokenKind.For);
+        return new Statement_1.ExitStatement({
+            exit: exitToken,
+            loopType: loopTypeToken
+        });
     }
     forStatement() {
+        var _a, _b;
         const forToken = this.advance();
         const initializer = this.assignment();
         //TODO: newline allowed?
@@ -628,7 +971,7 @@ class Parser {
         const finalValue = this.expression();
         let incrementExpression;
         let stepToken;
-        if (this.check(lexer_1.TokenKind.Step)) {
+        if (this.check(TokenKind_1.TokenKind.Step)) {
             stepToken = this.advance();
             incrementExpression = this.expression();
         }
@@ -636,125 +979,142 @@ class Parser {
             // BrightScript for/to/step loops default to a step of 1 if no `step` is provided
         }
         this.consumeStatementSeparators();
-        let body = this.block(lexer_1.TokenKind.EndFor, lexer_1.TokenKind.Next);
+        let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next, TokenKind_1.TokenKind.EndWhile);
         let endForToken;
-        if (!body || !this.checkAny(lexer_1.TokenKind.EndFor, lexer_1.TokenKind.Next)) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop()), { range: this.peek().range }));
+        if (body && this.checkAny(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next)) {
+            endForToken = this.advance();
+        }
+        else if (body && this.peek().kind === TokenKind_1.TokenKind.EndWhile) {
+            //recover: a stray `end while` is a common mistake when the user means `end for`.
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndingToken(['end for', 'next'], 'end while')), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
+            endForToken = this.advance();
+        }
+        else {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop(forToken.text)), { location: (_b = this.peek()) === null || _b === void 0 ? void 0 : _b.location }));
             if (!body) {
                 throw this.lastDiagnosticAsError();
             }
         }
-        else {
-            endForToken = this.advance();
-        }
         // 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() {
+        var _a;
         let forEach = this.advance();
-        let name = this.identifier();
+        let name = this.advance();
+        let asToken;
+        let typeExpression;
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            this.warnIfNotBrighterScriptMode('typed for each loop variable');
+            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+        }
         let maybeIn = this.peek();
-        if (this.check(lexer_1.TokenKind.Identifier) && maybeIn.text.toLowerCase() === 'in') {
+        if (this.check(TokenKind_1.TokenKind.Identifier) && maybeIn.text.toLowerCase() === 'in') {
             this.advance();
         }
         else {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInAfterForEach(name.text)), { range: this.peek().range }));
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.In)), { location: this.peek().location }));
             throw this.lastDiagnosticAsError();
         }
+        maybeIn.kind = TokenKind_1.TokenKind.In;
         let target = this.expression();
         if (!target) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedExpressionAfterForEachIn()), { range: this.peek().range }));
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedExpressionAfterForEachIn()), { location: this.peek().location }));
             throw this.lastDiagnosticAsError();
         }
         this.consumeStatementSeparators();
-        let body = this.block(lexer_1.TokenKind.EndFor, lexer_1.TokenKind.Next);
-        if (!body) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop()), { range: this.peek().range }));
-            throw this.lastDiagnosticAsError();
+        let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next, TokenKind_1.TokenKind.EndWhile);
+        let endFor;
+        if (body && this.checkAny(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next)) {
+            endFor = this.advance();
         }
-        let endFor = this.advance();
-        //TODO infer type from `target`
-        const itemType = new DynamicType_1.DynamicType();
-        this.currentSymbolTable.addSymbol(name.text, name.range, itemType);
-        return new Statement_1.ForEachStatement(forEach, name, maybeIn, target, body, endFor);
-    }
-    exitFor() {
-        let keyword = this.advance();
-        return new Statement_1.ExitForStatement({ exitFor: keyword });
-    }
-    commentStatement() {
-        //if this comment is on the same line as the previous statement,
-        //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()]);
+        else if (body && this.peek().kind === TokenKind_1.TokenKind.EndWhile) {
+            //recover: a stray `end while` is a common mistake when the user means `end for`.
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndingToken(['end for', 'next'], 'end while')), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
+            endFor = this.advance();
         }
         else {
-            let comments = [this.advance()];
-            while (this.check(lexer_1.TokenKind.Newline) && this.checkNext(lexer_1.TokenKind.Comment)) {
-                this.advance();
-                comments.push(this.advance());
-            }
-            return new Statement_1.CommentStatement(comments);
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop(forEach.text)), { location: this.peek().location }));
+            throw this.lastDiagnosticAsError();
         }
+        return new Statement_1.ForEachStatement({
+            forEach: forEach,
+            as: asToken,
+            typeExpression: typeExpression,
+            in: maybeIn,
+            endFor: endFor,
+            item: name,
+            target: target,
+            body: body
+        });
     }
     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;
-        this.globalTerminators.push([lexer_1.TokenKind.EndNamespace]);
+        this.globalTerminators.push([TokenKind_1.TokenKind.EndNamespace]);
         let body = this.body();
         this.globalTerminators.pop();
-        //unset the current namespace name
-        this.currentNamespace = undefined;
         let endKeyword;
-        if (this.check(lexer_1.TokenKind.EndNamespace)) {
+        if (this.check(TokenKind_1.TokenKind.EndNamespace)) {
             endKeyword = this.advance();
         }
         else {
             //the `end namespace` keyword is missing. add a diagnostic, but keep parsing
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('namespace')), { range: keyword.range }));
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('namespace')), { location: keyword.location }));
         }
         this.namespaceAndFunctionDepth--;
-        result.body = body;
-        result.endKeyword = endKeyword;
-        this._references.namespaceStatements.push(result);
+        let result = new Statement_1.NamespaceStatement({
+            namespace: keyword,
+            nameExpression: name,
+            body: body,
+            endNamespace: endKeyword
+        });
+        //cache the range property so that plugins can't affect it
+        result.cacheLocation();
+        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), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+    identifyingExpression(allowedTokenKinds) {
+        allowedTokenKinds = allowedTokenKinds !== null && allowedTokenKinds !== void 0 ? allowedTokenKinds : this.allowedLocalIdentifiers;
+        let firstIdentifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(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 = lexer_1.TokenKind.Identifier;
-            expr = new Expression_1.VariableExpression(firstIdentifier, null);
+            firstIdentifier.kind = TokenKind_1.TokenKind.Identifier;
+            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(lexer_1.TokenKind.Dot)) {
-                let dot = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(this.peek().text), lexer_1.TokenKind.Dot);
+            while (this.check(TokenKind_1.TokenKind.Dot)) {
+                let dot = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.Dot);
                 if (!dot) {
                     break;
                 }
-                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers, ...lexer_1.AllowedProperties);
+                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...allowedTokenKinds, ...TokenKind_1.AllowedProperties);
                 if (!identifier) {
                     break;
                 }
                 // force it into an identifier so the AST makes some sense
-                identifier.kind = lexer_1.TokenKind.Identifier;
-                expr = new Expression_1.DottedGetExpression(expr, identifier, dot);
+                identifier.kind = TokenKind_1.TokenKind.Identifier;
+                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.
@@ -762,13 +1122,13 @@ class Parser {
     flagUntil(...stopTokens) {
         while (!this.checkAny(...stopTokens) && !this.isAtEnd()) {
             let token = this.advance();
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(token.text)), { range: token.range }));
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(token.text)), { location: token.location }));
         }
     }
     /**
      * 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 = [];
@@ -778,33 +1138,91 @@ class Parser {
         }
         return result;
     }
+    constDeclaration() {
+        this.warnIfNotBrighterScriptMode('const declaration');
+        const constToken = this.advance();
+        const nameToken = this.identifier(...this.allowedLocalIdentifiers);
+        const equalToken = this.consumeToken(TokenKind_1.TokenKind.Equal);
+        const expression = this.expression();
+        const statement = new Statement_1.ConstStatement({
+            const: constToken,
+            name: nameToken,
+            equals: equalToken,
+            value: expression
+        });
+        return statement;
+    }
     libraryStatement() {
         let libStatement = new Statement_1.LibraryStatement({
             library: this.advance(),
             //grab the next token only if it's a string
-            filePath: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('library'), lexer_1.TokenKind.StringLiteral)
+            filePath: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('library'), TokenKind_1.TokenKind.StringLiteral)
         });
-        this._references.libraryStatements.push(libStatement);
         return libStatement;
     }
     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'), lexer_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
+            path: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import'), TokenKind_1.TokenKind.StringLiteral)
+        });
         return importStatement;
     }
+    typecastStatement() {
+        this.warnIfNotBrighterScriptMode('typecast statements');
+        const typecastToken = this.advance();
+        const typecastExpr = this.expression();
+        if ((0, reflection_1.isTypecastExpression)(typecastExpr)) {
+            return new Statement_1.TypecastStatement({
+                typecast: typecastToken,
+                typecastExpression: typecastExpr
+            });
+        }
+        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('typecast')), { location: {
+                uri: typecastToken.location.uri,
+                range: util_1.util.createBoundingRange(typecastToken, this.peek())
+            } }));
+        throw this.lastDiagnosticAsError();
+    }
+    aliasStatement() {
+        this.warnIfNotBrighterScriptMode('alias statements');
+        const aliasToken = this.advance();
+        const name = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('alias'), TokenKind_1.TokenKind.Identifier);
+        const equals = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.Equal), TokenKind_1.TokenKind.Equal);
+        let value = this.identifyingExpression();
+        let aliasStmt = new Statement_1.AliasStatement({
+            alias: aliasToken,
+            name: name,
+            equals: equals,
+            value: value
+        });
+        return aliasStmt;
+    }
+    typeStatement() {
+        this.warnIfNotBrighterScriptMode('type statements');
+        const typeToken = this.advance();
+        const name = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('type'), TokenKind_1.TokenKind.Identifier);
+        const equals = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.Equal), TokenKind_1.TokenKind.Equal);
+        let value = this.typeExpression();
+        let typeStmt = new Statement_1.TypeStatement({
+            type: typeToken,
+            name: name,
+            equals: equals,
+            value: value
+        });
+        return typeStmt;
+    }
     annotationExpression() {
         const atToken = this.advance();
-        const identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+        const identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         if (identifier) {
-            identifier.kind = lexer_1.TokenKind.Identifier;
+            identifier.kind = TokenKind_1.TokenKind.Identifier;
         }
-        let annotation = new Expression_1.AnnotationExpression(atToken, identifier);
+        let annotation = new Expression_1.AnnotationExpression({ at: atToken, name: identifier });
         this.pendingAnnotations.push(annotation);
         //optional arguments
-        if (this.check(lexer_1.TokenKind.LeftParen)) {
+        if (this.check(TokenKind_1.TokenKind.LeftParen)) {
             let leftParen = this.advance();
             annotation.call = this.finishCall(leftParen, annotation, false);
         }
@@ -817,7 +1235,7 @@ class Parser {
         }
         const questionMarkToken = this.advance();
         //consume newlines or comments
-        while (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
+        while (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
             this.advance();
         }
         let consequent;
@@ -826,12 +1244,12 @@ class Parser {
         }
         catch (_a) { }
         //consume newlines or comments
-        while (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
+        while (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
             this.advance();
         }
-        const colonToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedTokenAButFoundTokenB(lexer_1.TokenKind.Colon, this.peek().text), lexer_1.TokenKind.Colon);
+        const colonToken = this.tryConsumeToken(TokenKind_1.TokenKind.Colon);
         //consume newlines
-        while (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
+        while (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
             this.advance();
         }
         let alternate;
@@ -839,136 +1257,179 @@ 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');
+        return new Expression_1.RegexLiteralExpression({
+            regexLiteral: this.advance()
+        });
     }
     templateString(isTagged) {
         this.warnIfNotBrighterScriptMode('template string');
         //get the tag name
         let tagName;
         if (isTagged) {
-            tagName = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+            tagName = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
             // force it into an identifier so the AST makes some sense
-            tagName.kind = lexer_1.TokenKind.Identifier;
+            tagName.kind = TokenKind_1.TokenKind.Identifier;
         }
         let quasis = [];
         let expressions = [];
         let openingBacktick = this.peek();
         this.advance();
         let currentQuasiExpressionParts = [];
-        while (!this.isAtEnd() && !this.check(lexer_1.TokenKind.BackTick)) {
+        while (!this.isAtEnd() && !this.check(TokenKind_1.TokenKind.BackTick)) {
             let next = this.peek();
-            if (next.kind === lexer_1.TokenKind.TemplateStringQuasi) {
+            if (next.kind === TokenKind_1.TokenKind.TemplateStringQuasi) {
                 //a quasi can actually be made up of multiple quasis when it includes char literals
-                currentQuasiExpressionParts.push(new Expression_1.LiteralExpression(next));
+                currentQuasiExpressionParts.push(new Expression_1.LiteralExpression({ value: next }));
                 this.advance();
             }
-            else if (next.kind === lexer_1.TokenKind.EscapedCharCodeLiteral) {
-                currentQuasiExpressionParts.push(new Expression_1.EscapedCharCodeLiteralExpression(next));
+            else if (next.kind === TokenKind_1.TokenKind.EscapedCharCodeLiteral) {
+                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 === lexer_1.TokenKind.TemplateStringExpressionBegin) {
+                if (next.kind === TokenKind_1.TokenKind.TemplateStringExpressionBegin) {
                     this.advance();
                 }
                 //now keep this expression
                 expressions.push(this.expression());
-                if (!this.isAtEnd() && this.check(lexer_1.TokenKind.TemplateStringExpressionEnd)) {
+                if (!this.isAtEnd() && this.check(TokenKind_1.TokenKind.TemplateStringExpressionEnd)) {
                     //TODO is it an error if this is not present?
                     this.advance();
                 }
                 else {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unterminatedTemplateExpression()), { range: util_1.util.getRange(openingBacktick, this.peek()) }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unterminatedTemplateExpression()), { location: {
+                            uri: openingBacktick.location.uri,
+                            range: util_1.util.createBoundingRange(openingBacktick, this.peek())
+                        } }));
                     throw this.lastDiagnosticAsError();
                 }
             }
         }
         //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()) }));
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unterminatedTemplateString()), { location: {
+                    uri: openingBacktick.location.uri,
+                    range: util_1.util.createBoundingRange(openingBacktick, this.peek())
+                } }));
             throw this.lastDiagnosticAsError();
         }
         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
+                });
             }
         }
     }
     tryCatchStatement() {
+        var _a;
         const tryToken = this.advance();
-        const statement = new Statement_1.TryCatchStatement(tryToken);
+        let endTryToken;
+        let catchStmt;
         //ensure statement separator
         this.consumeStatementSeparators();
-        statement.tryBranch = this.block(lexer_1.TokenKind.Catch, lexer_1.TokenKind.EndTry);
+        let tryBranch = this.block(TokenKind_1.TokenKind.Catch, TokenKind_1.TokenKind.EndTry);
         const peek = this.peek();
-        if (peek.kind !== lexer_1.TokenKind.Catch) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedCatchBlockInTryCatch()), { range: this.peek().range }));
-            //gracefully handle end-try
-            if (peek.kind === lexer_1.TokenKind.EndTry) {
-                statement.endTryToken = this.advance();
-            }
-            return statement;
+        if (peek.kind !== TokenKind_1.TokenKind.Catch) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedCatchBlockInTryCatch()), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
         }
         else {
-            statement.catchToken = this.advance();
-        }
-        const exceptionVarToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingExceptionVarToFollowCatch(), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
-        if (exceptionVarToken) {
-            // force it into an identifier so the AST makes some sense
-            exceptionVarToken.kind = lexer_1.TokenKind.Identifier;
-            statement.exceptionVariable = exceptionVarToken;
+            const catchToken = this.advance();
+            //get the exception variable as an expression
+            let exceptionVariableExpression;
+            //if we consumed any statement separators, that means we don't have an exception variable
+            if (this.consumeStatementSeparators(true)) {
+                //no exception variable. That's fine in BrighterScript but not in brightscript. But that'll get caught by the validator later...
+            }
+            else {
+                exceptionVariableExpression = this.expression(true);
+                this.consumeStatementSeparators();
+            }
+            const catchBranch = this.block(TokenKind_1.TokenKind.EndTry);
+            catchStmt = new Statement_1.CatchStatement({
+                catch: catchToken,
+                exceptionVariableExpression: exceptionVariableExpression,
+                catchBranch: catchBranch
+            });
         }
-        //ensure statement sepatator
-        this.consumeStatementSeparators();
-        statement.catchBranch = this.block(lexer_1.TokenKind.EndTry);
-        if (this.peek().kind !== lexer_1.TokenKind.EndTry) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndTryToTerminateTryCatch()), { range: this.peek().range }));
+        if (this.peek().kind !== TokenKind_1.TokenKind.EndTry) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedTerminator('end try', 'try-catch')), { location: this.peek().location }));
         }
         else {
-            statement.endTryToken = this.advance();
+            endTryToken = this.advance();
         }
+        const statement = new Statement_1.TryCatchStatement({
+            try: tryToken,
+            tryBranch: tryBranch,
+            catchStatement: catchStmt,
+            endTry: endTryToken
+        });
         return statement;
     }
     throwStatement() {
         const throwToken = this.advance();
         let expression;
-        if (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon)) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExceptionExpressionAfterThrowKeyword()), { range: throwToken.range }));
+        if (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExceptionExpressionAfterThrowKeyword()), { location: throwToken.location }));
         }
         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();
-        let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('dim'), lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+        let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('dim'), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
         // force to an identifier so the AST makes some sense
         if (identifier) {
-            identifier.kind = lexer_1.TokenKind.Identifier;
+            identifier.kind = TokenKind_1.TokenKind.Identifier;
         }
-        let leftSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingLeftSquareBracketAfterDimIdentifier(), lexer_1.TokenKind.LeftSquareBracket);
+        let leftSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken('['), TokenKind_1.TokenKind.LeftSquareBracket);
         let expressions = [];
         let expression;
         do {
             try {
                 expression = this.expression();
                 expressions.push(expression);
-                if (this.check(lexer_1.TokenKind.Comma)) {
+                if (this.check(TokenKind_1.TokenKind.Comma)) {
                     this.advance();
                 }
                 else {
@@ -980,23 +1441,28 @@ class Parser {
             }
         } while (expression);
         if (expressions.length === 0) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExpressionsInDimStatement()), { range: this.peek().range }));
-        }
-        let rightSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingRightSquareBracketAfterDimIdentifier(), lexer_1.TokenKind.RightSquareBracket);
-        return new Statement_1.DimStatement(dim, identifier, leftSquareBracket, expressions, rightSquareBracket);
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExpressionsInDimStatement()), { location: this.peek().location }));
+        }
+        let rightSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken('[', 'dim identifier'), TokenKind_1.TokenKind.RightSquareBracket);
+        return new Statement_1.DimStatement({
+            dim: dim,
+            name: identifier,
+            openingSquare: leftSquareBracket,
+            dimensions: expressions,
+            closingSquare: rightSquareBracket
+        });
     }
-    ifStatement() {
+    ifStatement(incrementNestedCount = true) {
         // colon before `if` is usually not allowed, unless it's after `then`
         if (this.current > 0) {
             const prev = this.previous();
-            if (prev.kind === lexer_1.TokenKind.Colon) {
-                if (this.current > 1 && this.tokens[this.current - 2].kind !== lexer_1.TokenKind.Then) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedColonBeforeIfStatement()), { range: prev.range }));
+            if (prev.kind === TokenKind_1.TokenKind.Colon) {
+                if (this.current > 1 && this.tokens[this.current - 2].kind !== TokenKind_1.TokenKind.Then && this.nestedInlineConditionalCount === 0) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedColonBeforeIfStatement()), { location: prev.location }));
                 }
             }
         }
         const ifToken = this.advance();
-        const startingRange = ifToken.range;
         const condition = this.expression();
         let thenBranch;
         let elseBranch;
@@ -1004,62 +1470,66 @@ class Parser {
         let endIfToken;
         let elseToken;
         //optional `then`
-        if (this.check(lexer_1.TokenKind.Then)) {
+        if (this.check(TokenKind_1.TokenKind.Then)) {
             thenToken = this.advance();
         }
         //is it inline or multi-line if?
-        const isInlineIfThen = !this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Comment);
+        const isInlineIfThen = !this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment);
         if (isInlineIfThen) {
             /*** PARSE INLINE IF STATEMENT ***/
-            thenBranch = this.inlineConditionalBranch(lexer_1.TokenKind.Else, lexer_1.TokenKind.EndIf);
+            if (!incrementNestedCount) {
+                this.nestedInlineConditionalCount++;
+            }
+            thenBranch = this.inlineConditionalBranch(TokenKind_1.TokenKind.Else, TokenKind_1.TokenKind.EndIf);
             if (!thenBranch) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatementToFollowConditionalCondition(ifToken.text)), { range: this.peek().range }));
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatement(ifToken.text, 'statement')), { location: this.peek().location }));
                 throw this.lastDiagnosticAsError();
             }
             else {
                 this.ensureInline(thenBranch.statements);
             }
             //else branch
-            if (this.check(lexer_1.TokenKind.Else)) {
+            if (this.check(TokenKind_1.TokenKind.Else)) {
                 elseToken = this.advance();
-                if (this.check(lexer_1.TokenKind.If)) {
+                if (this.check(TokenKind_1.TokenKind.If)) {
                     // recurse-read `else if`
-                    elseBranch = this.ifStatement();
+                    elseBranch = this.ifStatement(false);
                     //no multi-line if chained with an inline if
                     if (!elseBranch.isInline) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement()), { range: elseBranch.range }));
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement()), { location: elseBranch.location }));
                     }
                 }
-                else if (this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon)) {
+                else if (this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon)) {
                     //expecting inline else branch
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement()), { range: this.peek().range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement()), { location: this.peek().location }));
                     throw this.lastDiagnosticAsError();
                 }
                 else {
-                    elseBranch = this.inlineConditionalBranch(lexer_1.TokenKind.Else, lexer_1.TokenKind.EndIf);
+                    elseBranch = this.inlineConditionalBranch(TokenKind_1.TokenKind.Else, TokenKind_1.TokenKind.EndIf);
                     if (elseBranch) {
                         this.ensureInline(elseBranch.statements);
                     }
                 }
                 if (!elseBranch) {
                     //missing `else` branch
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatementToFollowElse()), { range: this.peek().range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatement('else', 'statement')), { location: this.peek().location }));
                     throw this.lastDiagnosticAsError();
                 }
             }
-            if (!elseBranch || !reflection_1.isIfStatement(elseBranch)) {
+            if (!elseBranch || !(0, reflection_1.isIfStatement)(elseBranch)) {
                 //enforce newline at the end of the inline if statement
                 const peek = this.peek();
-                if (peek.kind !== lexer_1.TokenKind.Newline && peek.kind !== lexer_1.TokenKind.Comment && !this.isAtEnd()) {
+                if (peek.kind !== TokenKind_1.TokenKind.Newline && peek.kind !== TokenKind_1.TokenKind.Comment && peek.kind !== TokenKind_1.TokenKind.Else && !this.isAtEnd()) {
                     //ignore last error if it was about a colon
-                    if (this.previous().kind === lexer_1.TokenKind.Colon) {
+                    if (this.previous().kind === TokenKind_1.TokenKind.Colon) {
                         this.diagnostics.pop();
                         this.current--;
                     }
                     //newline is required
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedFinalNewline()), { range: this.peek().range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedFinalNewline()), { location: this.peek().location }));
                 }
             }
+            this.nestedInlineConditionalCount--;
         }
         else {
             /*** PARSE MULTI-LINE IF STATEMENT ***/
@@ -1067,9 +1537,9 @@ class Parser {
             //ensure newline/colon before next keyword
             this.ensureNewLineOrColon();
             //else branch
-            if (this.check(lexer_1.TokenKind.Else)) {
+            if (this.check(TokenKind_1.TokenKind.Else)) {
                 elseToken = this.advance();
-                if (this.check(lexer_1.TokenKind.If)) {
+                if (this.check(TokenKind_1.TokenKind.If)) {
                     // recurse-read `else if`
                     elseBranch = this.ifStatement();
                 }
@@ -1079,13 +1549,13 @@ class Parser {
                     this.ensureNewLineOrColon();
                 }
             }
-            if (!reflection_1.isIfStatement(elseBranch)) {
-                if (this.check(lexer_1.TokenKind.EndIf)) {
+            if (!(0, reflection_1.isIfStatement)(elseBranch)) {
+                if (this.check(TokenKind_1.TokenKind.EndIf)) {
                     endIfToken = this.advance();
                 }
                 else {
                     //missing endif
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndIfToCloseIfStatement(startingRange.start)), { range: ifToken.range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedTerminator('end if', 'if')), { location: ifToken.location }));
                 }
             }
         }
@@ -1093,8 +1563,11 @@ class Parser {
             if: ifToken,
             then: thenToken,
             endIf: endIfToken,
-            else: elseToken
-        }, condition, thenBranch, elseBranch, isInlineIfThen);
+            else: elseToken,
+            condition: condition,
+            thenBranch: thenBranch,
+            elseBranch: elseBranch
+        });
     }
     //consume a `then` or `else` branch block of an `if` statement
     blockConditionalBranch(ifToken) {
@@ -1103,23 +1576,220 @@ class Parser {
         let diagnosticsLengthBeforeBlock = this.diagnostics.length;
         // we're parsing a multi-line ("block") form of the BrightScript if/then and must find
         // a trailing "end if" or "else if"
-        let branch = this.block(lexer_1.TokenKind.EndIf, lexer_1.TokenKind.Else);
+        let branch = this.block(TokenKind_1.TokenKind.EndIf, TokenKind_1.TokenKind.Else);
+        if (!branch) {
+            //throw out any new diagnostics created as a result of a `then` block parse failure.
+            //the block() function will discard the current line, so any discarded diagnostics will
+            //resurface if they are legitimate, and not a result of a malformed if statement
+            this.diagnostics.splice(diagnosticsLengthBeforeBlock, this.diagnostics.length - diagnosticsLengthBeforeBlock);
+            //this whole if statement is bogus...add error to the if token and hard-fail
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedTerminator(['end if', 'else if', 'else'], 'then', 'block')), { location: ifToken.location }));
+            throw this.lastDiagnosticAsError();
+        }
+        return branch;
+    }
+    conditionalCompileStatement() {
+        var _a, _b;
+        const hashIfToken = this.advance();
+        let notToken;
+        if (this.check(TokenKind_1.TokenKind.Not)) {
+            notToken = this.advance();
+        }
+        if (!this.checkAny(TokenKind_1.TokenKind.True, TokenKind_1.TokenKind.False, TokenKind_1.TokenKind.Identifier)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidHashIfValue()), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
+        }
+        const condition = this.advance();
+        let thenBranch;
+        let elseBranch;
+        let hashEndIfToken;
+        let hashElseToken;
+        //keep track of the current error count
+        //if this is `#if false` remove all diagnostics.
+        let diagnosticsLengthBeforeBlock = this.diagnostics.length;
+        thenBranch = this.blockConditionalCompileBranch(hashIfToken);
+        const conditionTextLower = condition.text.toLowerCase();
+        if (!((_b = this.options.bsConsts) === null || _b === void 0 ? void 0 : _b.get(conditionTextLower)) || conditionTextLower === 'false') {
+            //throw out any new diagnostics created as a result of a false block
+            this.diagnostics.splice(diagnosticsLengthBeforeBlock, this.diagnostics.length - diagnosticsLengthBeforeBlock);
+        }
+        this.ensureNewLine();
+        this.advance();
+        //else branch
+        if (this.check(TokenKind_1.TokenKind.HashElseIf)) {
+            // recurse-read `#else if`
+            elseBranch = this.conditionalCompileStatement();
+            this.ensureNewLine();
+        }
+        else if (this.check(TokenKind_1.TokenKind.HashElse)) {
+            hashElseToken = this.advance();
+            let diagnosticsLengthBeforeBlock = this.diagnostics.length;
+            elseBranch = this.blockConditionalCompileBranch(hashIfToken);
+            if (condition.text.toLowerCase() === 'true') {
+                //throw out any new diagnostics created as a result of a false block
+                this.diagnostics.splice(diagnosticsLengthBeforeBlock, this.diagnostics.length - diagnosticsLengthBeforeBlock);
+            }
+            this.ensureNewLine();
+            this.advance();
+        }
+        if (!(0, reflection_1.isConditionalCompileStatement)(elseBranch)) {
+            if (this.check(TokenKind_1.TokenKind.HashEndIf)) {
+                hashEndIfToken = this.advance();
+            }
+            else {
+                //missing #endif
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedTerminator('#end if', '#if')), { location: hashIfToken.location }));
+            }
+        }
+        return new Statement_1.ConditionalCompileStatement({
+            hashIf: hashIfToken,
+            hashElse: hashElseToken,
+            hashEndIf: hashEndIfToken,
+            not: notToken,
+            condition: condition,
+            thenBranch: thenBranch,
+            elseBranch: elseBranch
+        });
+    }
+    //consume a conditional compile branch block of an `#if` statement
+    blockConditionalCompileBranch(hashIfToken) {
+        //keep track of the current error count, because if the then branch fails,
+        //we will trash them in favor of a single error on if
+        let diagnosticsLengthBeforeBlock = this.diagnostics.length;
+        //parsing until trailing "#end if", "#else", "#else if"
+        let branch = this.conditionalCompileBlock();
         if (!branch) {
             //throw out any new diagnostics created as a result of a `then` block parse failure.
             //the block() function will discard the current line, so any discarded diagnostics will
             //resurface if they are legitimate, and not a result of a malformed if statement
             this.diagnostics.splice(diagnosticsLengthBeforeBlock, this.diagnostics.length - diagnosticsLengthBeforeBlock);
             //this whole if statement is bogus...add error to the if token and hard-fail
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndIfElseIfOrElseToTerminateThenBlock()), { range: ifToken.range }));
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedTerminator(['#end if', '#else if', '#else'], 'conditional compilation', 'block')), { location: hashIfToken.location }));
             throw this.lastDiagnosticAsError();
         }
         return branch;
     }
+    /**
+     * Parses a block, looking for a specific terminating TokenKind to denote completion.
+     * Always looks for `#end if` or `#else`
+     */
+    conditionalCompileBlock() {
+        const parentAnnotations = this.enterAnnotationBlock();
+        this.consumeStatementSeparators(true);
+        const unsafeTerminators = TokenKind_1.BlockTerminators;
+        const conditionalEndTokens = [TokenKind_1.TokenKind.HashElse, TokenKind_1.TokenKind.HashElseIf, TokenKind_1.TokenKind.HashEndIf];
+        const terminators = [...conditionalEndTokens, ...unsafeTerminators];
+        this.globalTerminators.push(conditionalEndTokens);
+        const statements = [];
+        while (!this.isAtEnd() && !this.checkAny(...terminators)) {
+            //grab the location of the current token
+            let loopCurrent = this.current;
+            let dec = this.declaration();
+            if (dec) {
+                if (!(0, reflection_1.isAnnotationExpression)(dec)) {
+                    this.consumePendingAnnotations(dec);
+                    statements.push(dec);
+                }
+                const peekKind = this.peek().kind;
+                if (conditionalEndTokens.includes(peekKind)) {
+                    // current conditional compile branch was closed by other statement, rewind to preceding newline
+                    this.current--;
+                }
+                //ensure statement separator
+                this.consumeStatementSeparators();
+            }
+            else {
+                //something went wrong. reset to the top of the loop
+                this.current = loopCurrent;
+                //scrap the entire line (hopefully whatever failed has added a diagnostic)
+                this.consumeUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
+                //trash the next token. this prevents an infinite loop. not exactly sure why we need this,
+                //but there's already an error in the file being parsed, so just leave this line here
+                this.advance();
+                //consume potential separators
+                this.consumeStatementSeparators(true);
+            }
+        }
+        this.globalTerminators.pop();
+        if (this.isAtEnd()) {
+            return undefined;
+            // TODO: Figure out how to handle unterminated blocks well
+        }
+        else {
+            //did we  hit an unsafe terminator?
+            //if so, we need to restore the statement separator
+            let prev = this.previous();
+            let prevKind = prev.kind;
+            let peek = this.peek();
+            let peekKind = this.peek().kind;
+            if ((peekKind === TokenKind_1.TokenKind.HashEndIf || peekKind === TokenKind_1.TokenKind.HashElse || peekKind === TokenKind_1.TokenKind.HashElseIf) &&
+                (prevKind === TokenKind_1.TokenKind.Newline)) {
+                this.current--;
+            }
+            else if (unsafeTerminators.includes(peekKind) &&
+                (prevKind === TokenKind_1.TokenKind.Newline || prevKind === TokenKind_1.TokenKind.Colon)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unsafeUnmatchedTerminatorInConditionalCompileBlock(peek.text)), { location: peek.location }));
+                throw this.lastDiagnosticAsError();
+            }
+            else {
+                return undefined;
+            }
+        }
+        this.exitAnnotationBlock(parentAnnotations);
+        return new Statement_1.Block({ statements: statements });
+    }
+    conditionalCompileConstStatement() {
+        var _a, _b, _c, _d, _e;
+        const hashConstToken = this.advance();
+        const constName = this.peek();
+        //disallow using keywords for const names
+        if (TokenKind_1.ReservedWords.has(constName === null || constName === void 0 ? void 0 : constName.text.toLowerCase())) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(constName === null || constName === void 0 ? void 0 : constName.text)), { location: constName === null || constName === void 0 ? void 0 : constName.location }));
+            this.lastDiagnosticAsError();
+            return;
+        }
+        const assignment = this.assignment();
+        if (assignment) {
+            // check for something other than #const <name> = <otherName|true|false>
+            if (assignment.tokens.as || assignment.typeExpression) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(((_a = assignment.tokens.as) === null || _a === void 0 ? void 0 : _a.text) || ((_b = assignment.typeExpression) === null || _b === void 0 ? void 0 : _b.getName(ParseMode.BrighterScript)))), { location: (_d = (_c = assignment.tokens.as) === null || _c === void 0 ? void 0 : _c.location) !== null && _d !== void 0 ? _d : (_e = assignment.typeExpression) === null || _e === void 0 ? void 0 : _e.location }));
+                this.lastDiagnosticAsError();
+            }
+            if ((0, reflection_1.isVariableExpression)(assignment.value) || (0, reflection_1.isLiteralBoolean)(assignment.value)) {
+                //value is an identifier or a boolean
+                //check for valid identifiers will happen in program validation
+            }
+            else {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidHashConstValue()), { location: assignment.value.location }));
+                this.lastDiagnosticAsError();
+            }
+        }
+        else {
+            return undefined;
+        }
+        if (!this.check(TokenKind_1.TokenKind.Newline)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text)), { location: this.peek().location }));
+            throw this.lastDiagnosticAsError();
+        }
+        return new Statement_1.ConditionalCompileConstStatement({ hashConst: hashConstToken, assignment: assignment });
+    }
+    conditionalCompileErrorStatement() {
+        const hashErrorToken = this.advance();
+        const tokensUntilEndOfLine = this.consumeUntil(TokenKind_1.TokenKind.Newline);
+        const message = (0, creators_1.createToken)(TokenKind_1.TokenKind.HashErrorMessage, tokensUntilEndOfLine.map(t => t.text).join(' '));
+        return new Statement_1.ConditionalCompileErrorStatement({ hashError: hashErrorToken, message: message });
+    }
+    ensureNewLine() {
+        //ensure newline before next keyword
+        if (!this.check(TokenKind_1.TokenKind.Newline)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text)), { location: this.peek().location }));
+            throw this.lastDiagnosticAsError();
+        }
+    }
     ensureNewLineOrColon(silent = false) {
         const prev = this.previous().kind;
-        if (prev !== lexer_1.TokenKind.Newline && prev !== lexer_1.TokenKind.Colon) {
+        if (prev !== TokenKind_1.TokenKind.Newline && prev !== TokenKind_1.TokenKind.Colon) {
             if (!silent) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedNewlineOrColon()), { range: this.peek().range }));
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedNewlineOrColon()), { location: this.peek().location }));
             }
             return false;
         }
@@ -1128,8 +1798,8 @@ class Parser {
     //ensure each statement of an inline block is single-line
     ensureInline(statements) {
         for (const stat of statements) {
-            if (reflection_1.isIfStatement(stat) && !stat.isInline) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement()), { range: stat.range }));
+            if ((0, reflection_1.isIfStatement)(stat) && !stat.isInline) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement()), { location: stat.location }));
             }
         }
     }
@@ -1145,12 +1815,12 @@ class Parser {
         statements.push(statement);
         //look for colon statement separator
         let foundColon = false;
-        while (this.match(lexer_1.TokenKind.Colon)) {
+        while (this.match(TokenKind_1.TokenKind.Colon)) {
             foundColon = true;
         }
         //if a colon was found, add the next statement or err if unexpected
         if (foundColon) {
-            if (!this.checkAny(lexer_1.TokenKind.Newline, ...additionalTerminators)) {
+            if (!this.checkAny(TokenKind_1.TokenKind.Newline, ...additionalTerminators)) {
                 //if not an ending keyword, add next statement
                 let extra = this.inlineConditionalBranch(...additionalTerminators);
                 if (!extra) {
@@ -1161,31 +1831,53 @@ class Parser {
             else {
                 //error: colon before next keyword
                 const colon = this.previous();
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(colon.text)), { range: colon.range }));
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(colon.text)), { location: colon.location }));
             }
         }
-        return new Statement_1.Block(statements, this.peek().range);
+        return new Statement_1.Block({ statements: statements });
     }
     expressionStatement(expr) {
         let expressionStart = this.peek();
-        if (this.checkAny(lexer_1.TokenKind.PlusPlus, lexer_1.TokenKind.MinusMinus)) {
+        if (this.checkAny(TokenKind_1.TokenKind.PlusPlus, TokenKind_1.TokenKind.MinusMinus)) {
             let operator = this.advance();
-            if (this.checkAny(lexer_1.TokenKind.PlusPlus, lexer_1.TokenKind.MinusMinus)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.consecutiveIncrementDecrementOperatorsAreNotAllowed()), { range: this.peek().range }));
+            if (this.checkAny(TokenKind_1.TokenKind.PlusPlus, TokenKind_1.TokenKind.MinusMinus)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedOperator()), { location: this.peek().location }));
                 throw this.lastDiagnosticAsError();
             }
-            else if (reflection_1.isCallExpression(expr)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.incrementDecrementOperatorsAreNotAllowedAsResultOfFunctionCall()), { range: expressionStart.range }));
+            else if ((0, reflection_1.isCallExpression)(expr)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedOperator()), { location: expressionStart.location }));
                 throw this.lastDiagnosticAsError();
             }
-            return new Statement_1.IncrementStatement(expr, operator);
+            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({ expression: expr });
+        }
+        if (this.checkAny(...TokenKind_1.BinaryExpressionOperatorTokens)) {
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: this.advance(), right: this.expression() });
         }
-        if (reflection_1.isCallExpression(expr) || reflection_1.isCallfuncExpression(expr)) {
-            return new Statement_1.ExpressionStatement(expr);
+        //you're not allowed to do dottedGet or XmlAttrGet after a function call
+        if ((0, reflection_1.isDottedGetExpression)(expr)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.propAccessNotPermittedAfterFunctionCallInExpressionStatement('Property')), { location: util_1.util.createBoundingLocation(expr.tokens.dot, expr.tokens.name) }));
+            //we can recover gracefully here even though it's invalid syntax
+            return new Statement_1.ExpressionStatement({ expression: expr });
+            //you're not allowed to do indexedGet expressions after a function call
+        }
+        else if ((0, reflection_1.isIndexedGetExpression)(expr)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.propAccessNotPermittedAfterFunctionCallInExpressionStatement('Index')), { location: util_1.util.createBoundingLocation(expr.tokens.openingSquare, ...expr.indexes, expr.tokens.closingSquare) }));
+            //we can recover gracefully here even though it's invalid syntax
+            return new Statement_1.ExpressionStatement({ expression: expr });
+            //you're not allowed to do XmlAttrGet after a function call
+        }
+        else if ((0, reflection_1.isXmlAttributeGetExpression)(expr)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.propAccessNotPermittedAfterFunctionCallInExpressionStatement('XML attribute')), { location: util_1.util.createBoundingLocation(expr.tokens.at, expr.tokens.name) }));
+            //we can recover gracefully here even though it's invalid syntax
+            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
-        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression()), { range: expressionStart.range }));
-        throw this.lastDiagnosticAsError();
+        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatement()), { location: expressionStart.location }));
+        return new Statement_1.ExpressionStatement({ expression: expr });
     }
     setStatement() {
         /**
@@ -1195,35 +1887,51 @@ class Parser {
          * priority as standalone function calls though, so we can parse them in the same way.
          */
         let expr = this.call();
-        if (this.checkAny(...lexer_1.AssignmentOperators) && !(reflection_1.isCallExpression(expr))) {
+        if (this.check(TokenKind_1.TokenKind.Equal) && !((0, reflection_1.isCallExpression)(expr))) {
             let left = expr;
             let operator = this.advance();
             let right = this.expression();
             // Create a dotted or indexed "set" based on the left-hand side's type
-            if (reflection_1.isIndexedGetExpression(left)) {
-                return new Statement_1.IndexedSetStatement(left.obj, left.index, operator.kind === lexer_1.TokenKind.Equal
-                    ? right
-                    : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare);
+            if ((0, reflection_1.isIndexedGetExpression)(left)) {
+                return new Statement_1.IndexedSetStatement({
+                    obj: left.obj,
+                    indexes: left.indexes,
+                    value: right,
+                    openingSquare: left.tokens.openingSquare,
+                    closingSquare: left.tokens.closingSquare,
+                    equals: operator
+                });
             }
-            else if (reflection_1.isDottedGetExpression(left)) {
-                return new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === lexer_1.TokenKind.Equal
-                    ? right
-                    : new Expression_1.BinaryExpression(left, operator, right));
+            else if ((0, reflection_1.isDottedGetExpression)(left)) {
+                return new Statement_1.DottedSetStatement({
+                    obj: left.obj,
+                    name: left.tokens.name,
+                    value: right,
+                    dot: left.tokens.dot,
+                    equals: operator
+                });
             }
         }
+        else if (this.checkAny(...TokenKind_1.CompoundAssignmentOperators) && !((0, reflection_1.isCallExpression)(expr))) {
+            let left = expr;
+            let operator = this.advance();
+            let right = this.expression();
+            return new Statement_1.AugmentedAssignmentStatement({
+                item: left,
+                operator: operator,
+                value: right
+            });
+        }
         return this.expressionStatement(expr);
     }
     printStatement() {
         let printKeyword = this.advance();
         let values = [];
         while (!this.checkEndOfStatement()) {
-            if (this.check(lexer_1.TokenKind.Semicolon)) {
-                values.push(this.advance());
+            if (this.checkAny(TokenKind_1.TokenKind.Semicolon, TokenKind_1.TokenKind.Comma)) {
+                values.push(new Expression_1.PrintSeparatorExpression({ separator: this.advance() }));
             }
-            else if (this.check(lexer_1.TokenKind.Comma)) {
-                values.push(this.advance());
-            }
-            else if (this.check(lexer_1.TokenKind.Else)) {
+            else if (this.check(TokenKind_1.TokenKind.Else)) {
                 break; // inline branch
             }
             else {
@@ -1232,45 +1940,53 @@ class Parser {
         }
         //print statements can be empty, so look for empty print conditions
         if (!values.length) {
-            let emptyStringLiteral = creators_1.createStringLiteral('');
+            const endOfStatementLocation = util_1.util.createBoundingLocation(printKeyword, this.peek());
+            let emptyStringLiteral = (0, creators_1.createStringLiteral)('', endOfStatementLocation);
             values.push(emptyStringLiteral);
         }
         let last = values[values.length - 1];
-        if (lexer_1.isToken(last)) {
+        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(lexer_1.TokenKind.Else) ? undefined : this.expression();
-        return new Statement_1.ReturnStatement(tokens, toReturn);
+        let toReturn = this.check(TokenKind_1.TokenKind.Else) ? undefined : this.expression();
+        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
-        if (!this.checkAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
+        if (!this.checkAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
             //rewind and cancel
             this.current -= 2;
             throw new CancelStatementError();
         }
-        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
@@ -1279,7 +1995,7 @@ class Parser {
     gotoStatement() {
         let tokens = {
             goto: this.advance(),
-            label: this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLabelIdentifierAfterGotoKeyword(), lexer_1.TokenKind.Identifier)
+            label: this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLabelIdentifierAfterGotoKeyword(), TokenKind_1.TokenKind.Identifier)
         };
         return new Statement_1.GotoStatement(tokens);
     }
@@ -1288,16 +2004,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.
@@ -1308,14 +2024,14 @@ class Parser {
     block(...terminators) {
         const parentAnnotations = this.enterAnnotationBlock();
         this.consumeStatementSeparators(true);
-        let startingToken = this.peek();
         const statements = [];
-        while (!this.isAtEnd() && !this.checkAny(lexer_1.TokenKind.EndSub, lexer_1.TokenKind.EndFunction, ...terminators)) {
+        const flatGlobalTerminators = this.globalTerminators.flat().flat();
+        while (!this.isAtEnd() && !this.checkAny(TokenKind_1.TokenKind.EndSub, TokenKind_1.TokenKind.EndFunction, ...terminators, ...flatGlobalTerminators)) {
             //grab the location of the current token
             let loopCurrent = this.current;
             let dec = this.declaration();
             if (dec) {
-                if (!reflection_1.isAnnotationExpression(dec)) {
+                if (!(0, reflection_1.isAnnotationExpression)(dec)) {
                     this.consumePendingAnnotations(dec);
                     statements.push(dec);
                 }
@@ -1326,7 +2042,7 @@ class Parser {
                 //something went wrong. reset to the top of the loop
                 this.current = loopCurrent;
                 //scrap the entire line (hopefully whatever failed has added a diagnostic)
-                this.consumeUntil(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Eof);
+                this.consumeUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
                 //trash the next token. this prevents an infinite loop. not exactly sure why we need this,
                 //but there's already an error in the file being parsed, so just leave this line here
                 this.advance();
@@ -1343,13 +2059,13 @@ class Parser {
             //if so, we need to restore the statement separator
             let prev = this.previous().kind;
             let peek = this.peek().kind;
-            if ((peek === lexer_1.TokenKind.EndSub || peek === lexer_1.TokenKind.EndFunction) &&
-                (prev === lexer_1.TokenKind.Newline || prev === lexer_1.TokenKind.Colon)) {
+            if ((peek === TokenKind_1.TokenKind.EndSub || peek === TokenKind_1.TokenKind.EndFunction) &&
+                (prev === TokenKind_1.TokenKind.Newline || prev === TokenKind_1.TokenKind.Colon)) {
                 this.current--;
             }
         }
         this.exitAnnotationBlock(parentAnnotations);
-        return new Statement_1.Block(statements, startingToken.range);
+        return new Statement_1.Block({ statements: statements });
     }
     /**
      * Attach pending annotations to the provided statement,
@@ -1370,19 +2086,39 @@ class Parser {
         // non consumed annotations are an error
         if (this.pendingAnnotations.length) {
             for (const annotation of this.pendingAnnotations) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation()), { range: annotation.range }));
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation()), { location: annotation.location }));
             }
         }
         this.pendingAnnotations = parentAnnotations;
     }
-    expression() {
-        return this.anonymousFunction();
+    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(lexer_1.TokenKind.Sub, lexer_1.TokenKind.Function)) {
+        if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
             const func = this.functionDeclaration(true);
             //if there's an open paren after this, this is an IIFE
-            if (this.check(lexer_1.TokenKind.LeftParen)) {
+            if (this.check(TokenKind_1.TokenKind.LeftParen)) {
                 return this.finishCall(this.advance(), func);
             }
             else {
@@ -1390,10 +2126,10 @@ class Parser {
             }
         }
         let expr = this.boolean();
-        if (this.check(lexer_1.TokenKind.Question)) {
+        if (this.check(TokenKind_1.TokenKind.Question)) {
             return this.ternaryExpression(expr);
         }
-        else if (this.check(lexer_1.TokenKind.QuestionQuestion)) {
+        else if (this.check(TokenKind_1.TokenKind.QuestionQuestion)) {
             return this.nullCoalescingExpression(expr);
         }
         else {
@@ -1402,127 +2138,186 @@ class Parser {
     }
     boolean() {
         let expr = this.relational();
-        while (this.matchAny(lexer_1.TokenKind.And, lexer_1.TokenKind.Or)) {
+        while (this.matchAny(TokenKind_1.TokenKind.And, TokenKind_1.TokenKind.Or)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.relational();
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
     relational() {
         let expr = this.additive();
-        while (this.matchAny(lexer_1.TokenKind.Equal, lexer_1.TokenKind.LessGreater, lexer_1.TokenKind.Greater, lexer_1.TokenKind.GreaterEqual, lexer_1.TokenKind.Less, lexer_1.TokenKind.LessEqual)) {
+        while (this.matchAny(TokenKind_1.TokenKind.Equal, TokenKind_1.TokenKind.LessGreater, TokenKind_1.TokenKind.Greater, TokenKind_1.TokenKind.GreaterEqual, TokenKind_1.TokenKind.Less, TokenKind_1.TokenKind.LessEqual)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.additive();
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
     // TODO: bitshift
     additive() {
         let expr = this.multiplicative();
-        while (this.matchAny(lexer_1.TokenKind.Plus, lexer_1.TokenKind.Minus)) {
+        while (this.matchAny(TokenKind_1.TokenKind.Plus, TokenKind_1.TokenKind.Minus)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.multiplicative();
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
     multiplicative() {
         let expr = this.exponential();
-        while (this.matchAny(lexer_1.TokenKind.Forwardslash, lexer_1.TokenKind.Backslash, lexer_1.TokenKind.Star, lexer_1.TokenKind.Mod, lexer_1.TokenKind.LeftShift, lexer_1.TokenKind.RightShift)) {
+        while (this.matchAny(TokenKind_1.TokenKind.Forwardslash, TokenKind_1.TokenKind.Backslash, TokenKind_1.TokenKind.Star, TokenKind_1.TokenKind.Mod, TokenKind_1.TokenKind.LeftShift, TokenKind_1.TokenKind.RightShift)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.exponential();
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
     exponential() {
         let expr = this.prefixUnary();
-        while (this.match(lexer_1.TokenKind.Caret)) {
+        while (this.match(TokenKind_1.TokenKind.Caret)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.prefixUnary();
-            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 === lexer_1.TokenKind.Not || nextKind === lexer_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();
-        while (this.match(lexer_1.TokenKind.Newline)) { }
-        let index = this.expression();
-        while (this.match(lexer_1.TokenKind.Newline)) { }
-        let closingSquare = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightSquareBraceAfterArrayOrObjectIndex(), lexer_1.TokenKind.RightSquareBracket);
-        return new Expression_1.IndexedGetExpression(expr, index, openingSquare, closingSquare);
+        let questionDotToken = this.getMatchingTokenAtOffset(-2, TokenKind_1.TokenKind.QuestionDot);
+        let indexes = [];
+        //consume leading newlines
+        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        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)) { }
+        const closingSquare = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(openingSquare.text, 'array or object index'), TokenKind_1.TokenKind.RightSquareBracket);
+        return new Expression_1.IndexedGetExpression({
+            obj: expr,
+            indexes: indexes,
+            openingSquare: openingSquare,
+            closingSquare: closingSquare,
+            questionDot: questionDotToken
+        });
     }
     newExpression() {
         this.warnIfNotBrighterScriptMode(`using 'new' keyword to construct a class`);
         let newToken = this.advance();
-        let nameExpr = this.getNamespacedVariableNameExpression();
-        let leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(this.peek().text), lexer_1.TokenKind.LeftParen);
+        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 endOfStatementLocation = util_1.util.createBoundingLocation(newToken, this.peek());
+            const exprStmt = nameExpr !== null && nameExpr !== void 0 ? nameExpr : (0, creators_1.createStringLiteral)('', endOfStatementLocation);
+            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;
     }
     /**
      * A callfunc expression (i.e. `node@.someFunctionOnNode()`)
      */
     callfunc(callee) {
+        var _a;
         this.warnIfNotBrighterScriptMode('callfunc operator');
         let operator = this.previous();
-        let methodName = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
-        // force it into an identifier so the AST makes some sense
-        methodName.kind = lexer_1.TokenKind.Identifier;
-        let openParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOpenParenToFollowCallfuncIdentifier(), lexer_1.TokenKind.LeftParen);
-        let call = this.finishCall(openParen, callee, false);
-        return new Expression_1.CallfuncExpression(callee, operator, methodName, openParen, call.args, call.closingParen);
+        let methodName = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+        let openParen;
+        let call;
+        if (methodName) {
+            // force it into an identifier so the AST makes some sense
+            methodName.kind = TokenKind_1.TokenKind.Identifier;
+            openParen = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.LeftParen), TokenKind_1.TokenKind.LeftParen);
+            if (openParen) {
+                call = this.finishCall(openParen, callee, false);
+            }
+        }
+        return new Expression_1.CallfuncExpression({
+            callee: callee,
+            operator: operator,
+            methodName: methodName,
+            openingParen: openParen,
+            args: call === null || call === void 0 ? void 0 : call.args,
+            closingParen: (_a = call === null || call === void 0 ? void 0 : call.tokens) === null || _a === void 0 ? void 0 : _a.closingParen
+        });
     }
     call() {
-        if (this.check(lexer_1.TokenKind.New) && this.checkAnyNext(lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+        if (this.check(TokenKind_1.TokenKind.New) && this.checkAnyNext(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
             return this.newExpression();
         }
         let expr = this.primary();
         while (true) {
-            if (this.match(lexer_1.TokenKind.LeftParen)) {
+            if (this.matchAny(TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen)) {
                 expr = this.finishCall(this.previous(), expr);
             }
-            else if (this.match(lexer_1.TokenKind.LeftSquareBracket)) {
+            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(lexer_1.TokenKind.Callfunc)) {
+            else if (this.match(TokenKind_1.TokenKind.Callfunc)) {
                 expr = this.callfunc(expr);
             }
-            else if (this.match(lexer_1.TokenKind.Dot)) {
-                if (this.match(lexer_1.TokenKind.LeftSquareBracket)) {
+            else if (this.matchAny(TokenKind_1.TokenKind.Dot, TokenKind_1.TokenKind.QuestionDot)) {
+                if (this.match(TokenKind_1.TokenKind.LeftSquareBracket)) {
                     expr = this.indexedGet(expr);
                 }
                 else {
                     let dot = this.previous();
-                    let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedPropertyNameAfterPeriod(), lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties);
+                    let name = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+                    if (!name) {
+                        break;
+                    }
                     // force it into an identifier so the AST makes some sense
-                    name.kind = lexer_1.TokenKind.Identifier;
-                    expr = new Expression_1.DottedGetExpression(expr, name, dot);
-                    this.addPropertyHints(name);
+                    name.kind = TokenKind_1.TokenKind.Identifier;
+                    expr = new Expression_1.DottedGetExpression({ obj: expr, name: name, dot: dot });
                 }
             }
-            else if (this.check(lexer_1.TokenKind.At)) {
+            else if (this.checkAny(TokenKind_1.TokenKind.At, TokenKind_1.TokenKind.QuestionAt)) {
                 let dot = this.advance();
-                let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedAttributeNameAfterAtSymbol(), lexer_1.TokenKind.Identifier, ...lexer_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 = lexer_1.TokenKind.Identifier;
-                expr = new Expression_1.XmlAttributeGetExpression(expr, name, dot);
+                name.kind = TokenKind_1.TokenKind.Identifier;
+                if (!name) {
+                    break;
+                }
+                expr = new Expression_1.XmlAttributeGetExpression({ obj: expr, name: name, at: dot });
                 //only allow a single `@` expression
                 break;
             }
@@ -1533,178 +2328,313 @@ class Parser {
         return expr;
     }
     finishCall(openingParen, callee, addToCallExpressionList = true) {
+        var _a, _b, _c;
         let args = [];
-        while (this.match(lexer_1.TokenKind.Newline)) {
-        }
-        if (!this.check(lexer_1.TokenKind.RightParen)) {
+        this.consumeNewlinesIfAllowed();
+        if (!this.check(TokenKind_1.TokenKind.RightParen)) {
             do {
-                while (this.match(lexer_1.TokenKind.Newline)) { }
+                this.consumeNewlinesIfAllowed();
                 if (args.length >= Expression_1.CallExpression.MaximumArguments) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableArguments(args.length, Expression_1.CallExpression.MaximumArguments)), { range: this.peek().range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableArguments(args.length, Expression_1.CallExpression.MaximumArguments)), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
                     throw this.lastDiagnosticAsError();
                 }
-                args.push(this.expression());
-            } while (this.match(lexer_1.TokenKind.Comma));
-        }
-        while (this.match(lexer_1.TokenKind.Newline)) { }
-        const closingParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), lexer_1.TokenKind.RightParen);
-        if (reflection_1.isVariableExpression(callee)) {
-            callee.isCalled = true;
-        }
-        let expression = new Expression_1.CallExpression(callee, openingParen, closingParen, args, this.currentNamespaceName);
+                //if a newline appears where we'd next read an argument and line continuation isn't
+                //allowed in this mode, peek past the newlines: if the following token can't begin an
+                //argument expression (e.g. `end function`, `end sub`, EOF), this is clearly an
+                //unclosed-paren situation and we swallow the newlines so the diagnostic from
+                //expression() reports the surprising token rather than the newline itself.
+                if (!this.allowLineContinuation && this.check(TokenKind_1.TokenKind.Newline)) {
+                    let lookahead = this.current;
+                    while (((_b = this.tokens[lookahead]) === null || _b === void 0 ? void 0 : _b.kind) === TokenKind_1.TokenKind.Newline) {
+                        lookahead++;
+                    }
+                    const followingKind = (_c = this.tokens[lookahead]) === null || _c === void 0 ? void 0 : _c.kind;
+                    if (followingKind === TokenKind_1.TokenKind.EndFunction || followingKind === TokenKind_1.TokenKind.EndSub || followingKind === TokenKind_1.TokenKind.Eof) {
+                        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+                    }
+                }
+                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));
+        }
+        this.consumeNewlinesIfAllowed();
+        //if no closing `)` is in sight (e.g. we hit a newline that line-continuation is not allowed
+        //to swallow), consume newlines anyway as part of error recovery so the unmatched-left-token
+        //diagnostic points at the surprising token (e.g. `end sub`) rather than the `\n`. This also
+        //ensures the surrounding block sees a non-separator next token and emits its own
+        //`expectedNewlineOrColon` diagnostic.
+        const recoveredFromMissingRightParen = !this.check(TokenKind_1.TokenKind.RightParen);
+        if (recoveredFromMissingRightParen) {
+            while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        }
+        const closingParen = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(openingParen.text, 'function call arguments'), 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 always return a token of whatever is next to be parsed
+     * Creates a TypeExpression, which wraps standard ASTNodes that represent a BscType
      */
-    typeToken() {
-        let typeToken;
-        if (this.checkAny(...lexer_1.DeclarableTypes)) {
-            // Token is a built in type
-            typeToken = this.advance();
+    typeExpression() {
+        var _a;
+        const changedTokens = [];
+        try {
+            // handle types with 'and'/'or' operators
+            const expressionsWithOperator = [];
+            // find all expressions and operators
+            let expr = this.getTypeExpressionPart(changedTokens);
+            while (this.options.mode === ParseMode.BrighterScript && this.matchAny(TokenKind_1.TokenKind.Or, TokenKind_1.TokenKind.And)) {
+                let operator = this.previous();
+                expressionsWithOperator.push({ expression: expr, operator: operator });
+                expr = this.getTypeExpressionPart(changedTokens);
+            }
+            // add last expression
+            expressionsWithOperator.push({ expression: expr });
+            // handle expressions with order of operations - first "and", then "or"
+            const combineExpressions = (opToken) => {
+                let exprWithOp = expressionsWithOperator[0];
+                let index = 0;
+                while (exprWithOp === null || exprWithOp === void 0 ? void 0 : exprWithOp.operator) {
+                    if (exprWithOp.operator.kind === opToken) {
+                        const nextExpr = expressionsWithOperator[index + 1];
+                        const combinedExpr = new Expression_1.BinaryExpression({ left: exprWithOp.expression, operator: exprWithOp.operator, right: nextExpr.expression });
+                        // replace the two expressions with the combined one
+                        expressionsWithOperator.splice(index, 2, { expression: combinedExpr, operator: nextExpr.operator });
+                        exprWithOp = expressionsWithOperator[index];
+                    }
+                    else {
+                        index++;
+                        exprWithOp = expressionsWithOperator[index];
+                    }
+                }
+            };
+            combineExpressions(TokenKind_1.TokenKind.And);
+            combineExpressions(TokenKind_1.TokenKind.Or);
+            if ((_a = expressionsWithOperator[0]) === null || _a === void 0 ? void 0 : _a.expression) {
+                return new Expression_1.TypeExpression({ expression: expressionsWithOperator[0].expression });
+            }
         }
-        else if (this.options.mode === ParseMode.BrighterScript) {
-            try {
-                // see if we can get a namespaced identifer
-                const qualifiedType = this.getNamespacedVariableNameExpression();
-                typeToken = creators_1.createToken(lexer_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
+        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) {
+        var _a, _b;
+        let expr;
+        if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function) && this.checkNext(TokenKind_1.TokenKind.LeftParen)) {
+            // this is a tyyed function type expression, eg. "function(type1, type2) as type3"
+            this.warnIfNotBrighterScriptMode('typed function types');
+            expr = this.typedFunctionTypeExpression();
+        }
+        else if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
+            // if this is just a type, just use directly
+            expr = new Expression_1.VariableExpression({ name: this.advance() });
+        }
+        else {
+            if (this.options.mode === ParseMode.BrightScript && !declarableTypesLower.includes((_b = (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.toLowerCase())) {
+                //inline interfaces have their own diagnostic ('inline interface'); let `{`
+                //flow through to the matcher below so it fires the more-specific warning.
+                if (!this.check(TokenKind_1.TokenKind.LeftCurlyBrace)) {
+                    // custom types arrays not allowed in Brightscript
+                    this.warnIfNotBrighterScriptMode('custom types');
+                    this.advance(); // skip custom type token
+                    return expr;
+                }
+            }
+            if (this.match(TokenKind_1.TokenKind.LeftCurlyBrace)) {
+                expr = this.inlineInterface();
+            }
+            else if (this.match(TokenKind_1.TokenKind.LeftParen)) {
+                // this is a grouping type expression, ie. "(typeExpr)"
+                let left = this.previous();
+                let typeExpr = this.typeExpression();
+                let right = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(left.text, 'type expression'), TokenKind_1.TokenKind.RightParen);
+                expr = new Expression_1.GroupingExpression({ leftParen: left, rightParen: right, expression: typeExpr });
+            }
+            else {
+                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);
+            }
+        }
+        //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[]`
+            // 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();
+                    expr = new Expression_1.TypedArrayExpression({ innerType: expr, leftBracket: leftBracket, rightBracket: rightBracket });
+                }
             }
-            catch (_a) {
-                //could not get an identifier - just get whatever's next
-                typeToken = this.advance();
+        }
+        return expr;
+    }
+    typedFunctionTypeExpression() {
+        const funcOrSub = this.advance();
+        const openParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.LeftParen), TokenKind_1.TokenKind.LeftParen);
+        const 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)), { location: this.peek().location }));
+                }
+                params.push(this.functionParameter());
+            } while (this.match(TokenKind_1.TokenKind.Comma));
+        }
+        const closeParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(openParen.text, 'function type expression'), TokenKind_1.TokenKind.RightParen);
+        let asToken;
+        let returnType;
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            [asToken, returnType] = this.consumeAsTokenAndTypeExpression();
+        }
+        return new Expression_1.TypedFunctionTypeExpression({
+            functionType: funcOrSub,
+            rightParen: openParen,
+            params: params,
+            leftParen: closeParen,
+            as: asToken,
+            returnType: returnType
+        });
+    }
+    inlineInterface() {
+        let expr;
+        const openToken = this.previous();
+        this.warnIfNotBrighterScriptMode('inline interface');
+        const members = [];
+        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        while (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties, TokenKind_1.TokenKind.StringLiteral, TokenKind_1.TokenKind.Optional)) {
+            const member = this.inlineInterfaceMember();
+            members.push(member);
+            while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline)) { }
+        }
+        if (!this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedParameterNameButFound(this.peek().text)), { location: this.peek().location }));
+            throw this.lastDiagnosticAsError();
+        }
+        const closeToken = this.advance();
+        expr = new Expression_1.InlineInterfaceExpression({ open: openToken, members: members, close: closeToken });
+        return expr;
+    }
+    inlineInterfaceMember() {
+        let optionalKeyword = this.consumeTokenIf(TokenKind_1.TokenKind.Optional);
+        if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties, TokenKind_1.TokenKind.StringLiteral)) {
+            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 {
-            // just get whatever's next
-            typeToken = this.advance();
+            // no name after `optional` ... optional is the name
+            // rewind current token
+            optionalKeyword = null;
+            this.current--;
+        }
+        if (!this.checkAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers, TokenKind_1.TokenKind.StringLiteral)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(this.peek().text)), { location: this.peek().location }));
+            throw this.lastDiagnosticAsError();
+        }
+        let name;
+        if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+            name = this.identifier(...TokenKind_1.AllowedProperties);
+        }
+        else {
+            name = this.advance();
         }
-        return typeToken;
+        let typeExpression;
+        let asToken = null;
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+        }
+        return new Expression_1.InlineInterfaceMemberExpression({
+            name: name,
+            as: asToken,
+            typeExpression: typeExpression,
+            optional: optionalKeyword
+        });
     }
     primary() {
+        var _a;
         switch (true) {
-            case this.matchAny(lexer_1.TokenKind.False, lexer_1.TokenKind.True, lexer_1.TokenKind.Invalid, lexer_1.TokenKind.IntegerLiteral, lexer_1.TokenKind.LongIntegerLiteral, lexer_1.TokenKind.FloatLiteral, lexer_1.TokenKind.DoubleLiteral, lexer_1.TokenKind.StringLiteral):
-                return new Expression_1.LiteralExpression(this.previous());
+            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({ value: this.previous() });
             //capture source literals (LINE_NUM if brightscript, or a bunch of them if brighterscript)
-            case this.matchAny(lexer_1.TokenKind.LineNumLiteral, ...(this.options.mode === ParseMode.BrightScript ? [] : lexer_1.BrighterScriptSourceLiterals)):
-                return new Expression_1.SourceLiteralExpression(this.previous());
+            case this.matchAny(TokenKind_1.TokenKind.LineNumLiteral, ...(this.options.mode === ParseMode.BrightScript ? [] : TokenKind_1.BrighterScriptSourceLiterals)):
+                return new Expression_1.SourceLiteralExpression({ value: this.previous() });
             //template string
-            case this.check(lexer_1.TokenKind.BackTick):
+            case this.check(TokenKind_1.TokenKind.BackTick):
                 return this.templateString(false);
             //tagged template string (currently we do not support spaces between the identifier and the backtick)
-            case this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedLocalIdentifiers) && this.checkNext(lexer_1.TokenKind.BackTick):
+            case this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedLocalIdentifiers) && this.checkNext(TokenKind_1.TokenKind.BackTick):
                 return this.templateString(true);
-            case this.matchAny(lexer_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers):
-                return new Expression_1.VariableExpression(this.previous(), this.currentNamespaceName);
-            case this.match(lexer_1.TokenKind.LeftParen):
+            case this.matchAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers):
+                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(), lexer_1.TokenKind.RightParen);
-                return new Expression_1.GroupingExpression({ left: left, right: right }, expr);
-            case this.match(lexer_1.TokenKind.LeftSquareBracket):
-                let elements = [];
-                let openingSquare = this.previous();
-                //add any comment found right after the opening square
-                if (this.check(lexer_1.TokenKind.Comment)) {
-                    elements.push(new Statement_1.CommentStatement([this.advance()]));
-                }
-                while (this.match(lexer_1.TokenKind.Newline)) {
-                }
-                if (!this.match(lexer_1.TokenKind.RightSquareBracket)) {
-                    elements.push(this.expression());
-                    while (this.matchAny(lexer_1.TokenKind.Comma, lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment)) {
-                        if (this.checkPrevious(lexer_1.TokenKind.Comment) || this.check(lexer_1.TokenKind.Comment)) {
-                            let comment = this.check(lexer_1.TokenKind.Comment) ? this.advance() : this.previous();
-                            elements.push(new Statement_1.CommentStatement([comment]));
-                        }
-                        while (this.match(lexer_1.TokenKind.Newline)) {
-                        }
-                        if (this.check(lexer_1.TokenKind.RightSquareBracket)) {
-                            break;
-                        }
-                        elements.push(this.expression());
-                    }
-                    this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftSquareBraceAfterArrayLiteral(), lexer_1.TokenKind.RightSquareBracket);
-                }
-                let closingSquare = this.previous();
-                //this.consume("Expected newline or ':' after array literal", TokenKind.Newline, TokenKind.Colon, TokenKind.Eof);
-                return new Expression_1.ArrayLiteralExpression(elements, openingSquare, closingSquare);
-            case this.match(lexer_1.TokenKind.LeftCurlyBrace):
-                let openingBrace = this.previous();
-                let members = [];
-                let key = () => {
-                    let result = {
-                        colonToken: null,
-                        keyToken: null,
-                        range: null
-                    };
-                    if (this.checkAny(lexer_1.TokenKind.Identifier, ...lexer_1.AllowedProperties)) {
-                        result.keyToken = this.advance();
-                    }
-                    else if (this.check(lexer_1.TokenKind.StringLiteral)) {
-                        result.keyToken = this.advance();
-                    }
-                    else {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedAAKey()), { range: this.peek().range }));
-                        throw this.lastDiagnosticAsError();
-                    }
-                    result.colonToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), lexer_1.TokenKind.Colon);
-                    result.range = util_1.util.getRange(result.keyToken, result.colonToken);
-                    return result;
-                };
-                while (this.match(lexer_1.TokenKind.Newline)) {
-                }
-                if (!this.match(lexer_1.TokenKind.RightCurlyBrace)) {
-                    if (this.check(lexer_1.TokenKind.Comment)) {
-                        members.push(new Statement_1.CommentStatement([this.advance()]));
-                    }
-                    else {
-                        let k = key();
-                        let expr = this.expression();
-                        members.push(new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr));
-                    }
-                    while (this.matchAny(lexer_1.TokenKind.Comma, lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon, lexer_1.TokenKind.Comment)) {
-                        //check for comment at the end of the current line
-                        if (this.check(lexer_1.TokenKind.Comment) || this.checkPrevious(lexer_1.TokenKind.Comment)) {
-                            let token = this.checkPrevious(lexer_1.TokenKind.Comment) ? this.previous() : this.advance();
-                            members.push(new Statement_1.CommentStatement([token]));
-                        }
-                        else {
-                            while (this.matchAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon)) {
-                            }
-                            //check for a comment on its own line
-                            if (this.check(lexer_1.TokenKind.Comment) || this.checkPrevious(lexer_1.TokenKind.Comment)) {
-                                let token = this.checkPrevious(lexer_1.TokenKind.Comment) ? this.previous() : this.advance();
-                                members.push(new Statement_1.CommentStatement([token]));
-                                continue;
-                            }
-                            if (this.check(lexer_1.TokenKind.RightCurlyBrace)) {
-                                break;
-                            }
-                            let k = key();
-                            let expr = this.expression();
-                            members.push(new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr));
-                        }
-                    }
-                    this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), lexer_1.TokenKind.RightCurlyBrace);
-                }
-                let closingBrace = this.previous();
-                const aaExpr = new Expression_1.AALiteralExpression(members, openingBrace, closingBrace);
-                this.addPropertyHints(aaExpr);
-                return aaExpr;
-            case this.matchAny(lexer_1.TokenKind.Pos, lexer_1.TokenKind.Tab):
+                let right = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(left.text, 'expression'), TokenKind_1.TokenKind.RightParen);
+                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):
+                return this.aaLiteral();
+            case this.matchAny(TokenKind_1.TokenKind.Pos, TokenKind_1.TokenKind.Tab):
                 let token = Object.assign(this.previous(), {
-                    kind: lexer_1.TokenKind.Identifier
+                    kind: TokenKind_1.TokenKind.Identifier
                 });
-                return new Expression_1.VariableExpression(token, this.currentNamespaceName);
-            case this.checkAny(lexer_1.TokenKind.Function, lexer_1.TokenKind.Sub):
+                return new Expression_1.VariableExpression({ name: token });
+            case this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub):
                 return this.anonymousFunction();
-            case this.check(lexer_1.TokenKind.Comment):
-                return new Statement_1.CommentStatement([this.advance()]);
+            case this.check(TokenKind_1.TokenKind.RegexLiteral):
+                return this.regexLiteralExpression();
             default:
                 //if we found an expected terminator, don't throw a diagnostic...just return undefined
                 if (this.checkAny(...this.peekGlobalTerminators())) {
@@ -1712,11 +2642,120 @@ class Parser {
                     //something went wrong...throw an error so the upstream processor can scrap this line and move on
                 }
                 else {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken(this.peek().text)), { range: this.peek().range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text)), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
                     throw this.lastDiagnosticAsError();
                 }
         }
     }
+    arrayLiteral() {
+        let elements = [];
+        let openingSquare = this.previous();
+        while (this.match(TokenKind_1.TokenKind.Newline)) {
+        }
+        let closingSquare;
+        if (!this.match(TokenKind_1.TokenKind.RightSquareBracket)) {
+            try {
+                elements.push(this.expression());
+                while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
+                    while (this.match(TokenKind_1.TokenKind.Newline)) {
+                    }
+                    if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
+                        break;
+                    }
+                    elements.push(this.expression());
+                }
+            }
+            catch (error) {
+                this.rethrowNonDiagnosticError(error);
+            }
+            closingSquare = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(openingSquare.text, 'array literal'), TokenKind_1.TokenKind.RightSquareBracket);
+        }
+        else {
+            closingSquare = this.previous();
+        }
+        //this.consume("Expected newline or ':' after array literal", TokenKind.Newline, TokenKind.Colon, TokenKind.Eof);
+        return new Expression_1.ArrayLiteralExpression({ elements: elements, open: openingSquare, close: closingSquare });
+    }
+    aaLiteral() {
+        let openingBrace = this.previous();
+        let members = [];
+        let key = () => {
+            var _a;
+            let result = {
+                colon: null,
+                keyToken: null,
+                key: null,
+                leftBracket: null,
+                rightBracket: null,
+                range: null
+            };
+            if (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
+                // Computed key: [expr]
+                result.leftBracket = this.advance();
+                result.key = this.expression();
+                result.rightBracket = this.tryConsumeToken(TokenKind_1.TokenKind.RightSquareBracket);
+            }
+            else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+                result.keyToken = this.identifier(...TokenKind_1.AllowedProperties);
+            }
+            else if (this.check(TokenKind_1.TokenKind.StringLiteral)) {
+                result.keyToken = this.advance();
+            }
+            else {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedAAKey()), { location: this.peek().location }));
+                throw this.lastDiagnosticAsError();
+            }
+            result.colon = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), TokenKind_1.TokenKind.Colon);
+            result.range = util_1.util.createBoundingRange((_a = result.keyToken) !== null && _a !== void 0 ? _a : result.leftBracket, result.colon);
+            return result;
+        };
+        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        let closingBrace;
+        if (!this.match(TokenKind_1.TokenKind.RightCurlyBrace)) {
+            let lastAAMember;
+            try {
+                let k = key();
+                let expr = this.expression();
+                lastAAMember = k.key
+                    ? new Expression_1.AAIndexedMemberExpression({ leftBracket: k.leftBracket, key: k.key, rightBracket: k.rightBracket, colon: k.colon, value: expr })
+                    : new Expression_1.AAMemberExpression({
+                        key: k.keyToken,
+                        colon: k.colon,
+                        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();
+                    }
+                    this.consumeStatementSeparators(true);
+                    if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
+                        break;
+                    }
+                    let k = key();
+                    let expr = this.expression();
+                    lastAAMember = k.key
+                        ? new Expression_1.AAIndexedMemberExpression({ leftBracket: k.leftBracket, key: k.key, rightBracket: k.rightBracket, colon: k.colon, value: expr })
+                        : new Expression_1.AAMemberExpression({
+                            key: k.keyToken,
+                            colon: k.colon,
+                            value: expr
+                        });
+                    members.push(lastAAMember);
+                }
+            }
+            catch (error) {
+                this.rethrowNonDiagnosticError(error);
+            }
+            closingBrace = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(openingBrace.text, 'associative array literal'), TokenKind_1.TokenKind.RightCurlyBrace);
+        }
+        else {
+            closingBrace = this.previous();
+        }
+        const aaExpr = new Expression_1.AALiteralExpression({ elements: members, open: openingBrace, close: closingBrace });
+        return aaExpr;
+    }
     /**
      * Pop token if we encounter specified token
      */
@@ -1729,7 +2768,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) {
@@ -1740,6 +2779,21 @@ class Parser {
         }
         return false;
     }
+    /**
+     * If the next series of tokens matches the given set of tokens, pop them all
+     * @param tokenKinds a list of tokenKinds used to match the next set of tokens
+     */
+    matchSequence(...tokenKinds) {
+        var _a;
+        const endIndex = this.current + tokenKinds.length;
+        for (let i = 0; i < tokenKinds.length; i++) {
+            if (tokenKinds[i] !== ((_a = this.tokens[this.current + i]) === null || _a === void 0 ? void 0 : _a.kind)) {
+                return false;
+            }
+        }
+        this.current = endIndex;
+        return true;
+    }
     /**
      * Get next token matching a specified list, or fail with an error
      */
@@ -1754,29 +2808,45 @@ 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);
+    }
     /**
      * Consume, or add a message if not found. But then continue and return undefined
      */
     tryConsume(diagnostic, ...tokenKinds) {
+        var _a;
         const nextKind = this.peek().kind;
         let foundTokenKind = tokenKinds.some(tokenKind => nextKind === tokenKind);
         if (foundTokenKind) {
             return this.advance();
         }
-        this.diagnostics.push(Object.assign(Object.assign({}, diagnostic), { range: this.peek().range }));
+        this.diagnostics.push(Object.assign(Object.assign({}, diagnostic), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
+    }
+    tryConsumeToken(tokenKind) {
+        return this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(tokenKind), tokenKind);
     }
     consumeStatementSeparators(optional = false) {
+        var _a;
         //a comment or EOF mark the end of the statement
-        if (this.isAtEnd() || this.check(lexer_1.TokenKind.Comment)) {
+        if (this.isAtEnd() || this.check(TokenKind_1.TokenKind.Comment)) {
             return true;
         }
         let consumed = false;
         //consume any newlines and colons
-        while (this.matchAny(lexer_1.TokenKind.Newline, lexer_1.TokenKind.Colon)) {
+        while (this.matchAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon)) {
             consumed = true;
         }
         if (!optional && !consumed) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedNewlineOrColon()), { range: this.peek().range }));
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedNewlineOrColon()), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
         }
         return consumed;
     }
@@ -1788,22 +2858,27 @@ class Parser {
     }
     checkEndOfStatement() {
         const nextKind = this.peek().kind;
-        return [lexer_1.TokenKind.Colon, lexer_1.TokenKind.Newline, lexer_1.TokenKind.Comment, lexer_1.TokenKind.Eof].includes(nextKind);
+        return [TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Eof].includes(nextKind);
     }
     checkPrevious(tokenKind) {
         var _a;
         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 === lexer_1.TokenKind.Eof) {
+        if (nextKind === TokenKind_1.TokenKind.Eof) {
             return false;
         }
         return nextKind === tokenKind;
     }
     checkAny(...tokenKinds) {
         const nextKind = this.peek().kind;
-        if (nextKind === lexer_1.TokenKind.Eof) {
+        if (nextKind === TokenKind_1.TokenKind.Eof) {
             return false;
         }
         return tokenKinds.includes(nextKind);
@@ -1822,7 +2897,8 @@ class Parser {
         return tokenKinds.includes(nextKind);
     }
     isAtEnd() {
-        return this.peek().kind === lexer_1.TokenKind.Eof;
+        const peekToken = this.peek();
+        return !peekToken || peekToken.kind === TokenKind_1.TokenKind.Eof;
     }
     peekNext() {
         if (this.isAtEnd()) {
@@ -1836,6 +2912,33 @@ 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
+     * @param tokenKinds the desired token must match one of these
+     * @example
+     * getToken(-1); //returns the previous token.
+     * getToken(0);  //returns current token.
+     * getToken(1);  //returns next token
+     */
+    getMatchingTokenAtOffset(offset, ...tokenKinds) {
+        const token = this.tokens[this.current + offset];
+        if (tokenKinds.includes(token.kind)) {
+            return token;
+        }
+    }
     synchronize() {
         this.advance(); // skip the erroneous token
         while (!this.isAtEnd()) {
@@ -1844,16 +2947,16 @@ class Parser {
                 return;
             }
             switch (this.peek().kind) { //eslint-disable-line @typescript-eslint/switch-exhaustiveness-check
-                case lexer_1.TokenKind.Namespace:
-                case lexer_1.TokenKind.Class:
-                case lexer_1.TokenKind.Function:
-                case lexer_1.TokenKind.Sub:
-                case lexer_1.TokenKind.If:
-                case lexer_1.TokenKind.For:
-                case lexer_1.TokenKind.ForEach:
-                case lexer_1.TokenKind.While:
-                case lexer_1.TokenKind.Print:
-                case lexer_1.TokenKind.Return:
+                case TokenKind_1.TokenKind.Namespace:
+                case TokenKind_1.TokenKind.Class:
+                case TokenKind_1.TokenKind.Function:
+                case TokenKind_1.TokenKind.Sub:
+                case TokenKind_1.TokenKind.If:
+                case TokenKind_1.TokenKind.For:
+                case TokenKind_1.TokenKind.ForEach:
+                case TokenKind_1.TokenKind.While:
+                case TokenKind_1.TokenKind.Print:
+                case TokenKind_1.TokenKind.Return:
                     // start parsing again from the next block starter or obvious
                     // expression start
                     return;
@@ -1861,300 +2964,23 @@ class Parser {
             this.advance();
         }
     }
-    /**
-     * Get the token at the specified position
-     * @param position
-     */
-    getTokenAt(position) {
-        for (let token of this.tokens) {
-            if (util_1.util.rangeContains(token.range, position)) {
-                return token;
-            }
-        }
-    }
-    /**
-     * Get the token closest to the position. if no token is found, the previous token is returned
-     * @param position
-     * @param tokens
-     */
-    getClosestToken(position) {
-        let tokens = this.tokens;
-        for (let i = 0; i < tokens.length; i++) {
-            let token = tokens[i];
-            if (util_1.util.rangeContains(token.range, position)) {
-                return token;
-            }
-            //if the position less than this token range, then this position touches no token,
-            if (util_1.util.positionIsGreaterThanRange(position, token.range) === false) {
-                let t = tokens[i - 1];
-                //return the token or the first token
-                return t ? t : tokens[0];
-            }
-        }
-        //return the last token
-        return tokens[tokens.length - 1];
-    }
-    isPositionNextToTokenKind(position, tokenKind) {
-        const closestToken = this.getClosestToken(position);
-        const previousToken = this.getPreviousToken(closestToken);
-        const previousTokenKind = previousToken === null || previousToken === void 0 ? void 0 : previousToken.kind;
-        //next to matched token
-        if (!closestToken || closestToken.kind === lexer_1.TokenKind.Eof) {
-            return false;
-        }
-        else if (closestToken.kind === tokenKind) {
-            return true;
-        }
-        else if (closestToken.kind === lexer_1.TokenKind.Newline || previousTokenKind === lexer_1.TokenKind.Newline) {
-            return false;
-            //next to an identifier, which is next to token kind
-        }
-        else if (closestToken.kind === lexer_1.TokenKind.Identifier && previousTokenKind === tokenKind) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    getTokenBefore(currentToken, tokenKind) {
-        const index = this.tokens.indexOf(currentToken);
-        for (let i = index - 1; i >= 0; i--) {
-            currentToken = this.tokens[i];
-            if (currentToken.kind === lexer_1.TokenKind.Newline) {
-                break;
-            }
-            else if (currentToken.kind === tokenKind) {
-                return currentToken;
-            }
-        }
-        return undefined;
-    }
-    tokenFollows(currentToken, tokenKind) {
-        const index = this.tokens.indexOf(currentToken);
-        if (index > 0) {
-            return this.tokens[index - 1].kind === tokenKind;
-        }
-        return false;
-    }
-    getTokensUntil(currentToken, tokenKind, direction = -1) {
-        let tokens = [];
-        for (let i = this.tokens.indexOf(currentToken); direction === -1 ? i >= 0 : i === this.tokens.length; i += direction) {
-            currentToken = this.tokens[i];
-            if (currentToken.kind === lexer_1.TokenKind.Newline || currentToken.kind === tokenKind) {
-                break;
-            }
-            tokens.push(currentToken);
-        }
-        return tokens;
-    }
-    getPreviousToken(token) {
-        let idx = this.tokens.indexOf(token);
-        return this.tokens[idx - 1];
-    }
-    /**
-     * 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();
-        //gather up all the top-level statements
-        this.ast.walk(visitors_1.createVisitor({
-            ClassStatement: s => {
-                this._references.classStatements.push(s);
-            },
-            NamespaceStatement: s => {
-                this._references.namespaceStatements.push(s);
-            },
-            FunctionStatement: s => {
-                this._references.functionStatements.push(s);
-                //add the initial set of function expressions for function statements
-                this._references.functionExpressions.push(s.func);
-            },
-            ImportStatement: s => {
-                this._references.importStatements.push(s);
-            },
-            LibraryStatement: s => {
-                this._references.libraryStatements.push(s);
-            }
-        }), {
-            walkMode: visitors_1.WalkMode.visitStatements
-        });
-        let func;
-        let visitor = visitors_1.createVisitor({
-            AssignmentStatement: s => {
-                this._references.assignmentStatements.push(s);
-            },
-            FunctionExpression: (expression, parent) => {
-                if (!reflection_1.isClassMethodStatement(parent)) {
-                    this._references.functionExpressions.push(expression);
-                }
-            },
-            NewExpression: e => {
-                this._references.newExpressions.push(e);
-            },
-            AALiteralExpression: e => {
-                this.addPropertyHints(e);
-            },
-            DottedGetExpression: e => {
-                this.addPropertyHints(e.name);
-            },
-            DottedSetStatement: e => {
-                this.addPropertyHints(e.name);
-            }
-        });
-        //walk all function expressions (we'll add new ones as we move along too)
-        for (let i = 0; i < this._references.functionExpressions.length; i++) {
-            func = this._references.functionExpressions[i];
-            //walk this function expression
-            func.body.walk(visitor, {
-                walkMode: visitors_1.WalkMode.visitAll
-            });
-        }
-    }
     dispose() {
     }
 }
 exports.Parser = Parser;
+/**
+ * The minimum Roku firmware version that added native support for multi-line expressions
+ * (line continuation) in plain BrightScript (`.brs`) files.
+ */
+Parser.LINE_CONTINUATION_MIN_FIRMWARE_VERSION = '15.3.0';
 var ParseMode;
 (function (ParseMode) {
     ParseMode["BrightScript"] = "BrightScript";
     ParseMode["BrighterScript"] = "BrighterScript";
 })(ParseMode = exports.ParseMode || (exports.ParseMode = {}));
-class References {
-    constructor() {
-        this.assignmentStatements = [];
-        this.classStatements = [];
-        this.functionExpressions = [];
-        this.functionStatements = [];
-        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;
-    }
-}
-exports.References = References;
 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 {
-        //function
-        if (reflection_1.isFunctionExpression(expression)) {
-            return expression.getFunctionType();
-            //literal
-        }
-        else if (reflection_1.isLiteralExpression(expression)) {
-            return expression.type;
-            //Associative array literal
-        }
-        else if (reflection_1.isAALiteralExpression(expression)) {
-            return new ObjectType_1.ObjectType();
-            //Array literal
-        }
-        else if (reflection_1.isArrayLiteralExpression(expression)) {
-            return new ArrayType_1.ArrayType();
-            //function call
-        }
-        else if (reflection_1.isNewExpression(expression)) {
-            return new CustomType_1.CustomType(expression.className.getName(ParseMode.BrighterScript));
-            //Function call
-        }
-        else if (reflection_1.isCallExpression(expression)) {
-            return getTypeFromCallExpression(expression, functionExpression);
-        }
-        else if (reflection_1.isVariableExpression(expression)) {
-            return getTypeFromVariableExpression(expression, functionExpression);
-        }
-    }
-    catch (e) {
-        //do nothing. Just return dynamic
-    }
-    //fallback to dynamic
-    return new DynamicType_1.DynamicType();
-}
-exports.getBscTypeFromExpression = getBscTypeFromExpression;
-/**
- * Gets the return type of a function, taking into account that the function may not have been declared yet
- * If the callee already exists in symbol table, use that return type
- * otherwise, make a lazy type which will not compute its type until the file is done parsing
- *
- * @param call the Expression to process
- * @param functionExpression the wrapping function expression
- * @return the best guess type of that expression
- */
-function getTypeFromCallExpression(call, functionExpression) {
-    var _a;
-    let calleeName = (_a = call.callee.name.text) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-    if (calleeName) {
-        // i
-        const currentKnownType = functionExpression.symbolTable.getSymbolType(calleeName);
-        if (reflection_1.isFunctionType(currentKnownType)) {
-            return currentKnownType.returnType;
-        }
-        if (!reflection_1.isUninitializedType(currentKnownType)) {
-            // this will probably only happen if a functionName has been assigned to something else previously?
-            return currentKnownType;
-        }
-        return new LazyType_1.LazyType(() => {
-            const futureType = functionExpression.symbolTable.getSymbolType(calleeName);
-            if (reflection_1.isFunctionType(futureType)) {
-                return futureType.returnType;
-            }
-            return futureType;
-        });
-    }
-}
-exports.getTypeFromCallExpression = getTypeFromCallExpression;
-/**
- * Gets the type of a variable
- * if it already exists in symbol table, use that type
- * otherwise defer the type until first read, which will allow us to derive types from variables defined after this one (like from a loop perhaps)
- *
- * @param variable the Expression to process
- * @param functionExpression the wrapping function expression
- * @return the best guess type of that expression
- */
-function getTypeFromVariableExpression(variable, functionExpression) {
-    let variableName = variable.name.text.toLowerCase();
-    const currentKnownType = functionExpression.symbolTable.getSymbolType(variableName);
-    if (!reflection_1.isUninitializedType(currentKnownType)) {
-        return currentKnownType;
-    }
-    return new LazyType_1.LazyType(() => {
-        return functionExpression.symbolTable.getSymbolType(variableName);
-    });
-}
-exports.getTypeFromVariableExpression = getTypeFromVariableExpression;
 //# sourceMappingURL=Parser.js.map