brighterscript 1.0.0-alpha.25 → 1.0.0-alpha.27

package/dist/parser/Parser.js

@@ -11,7 +11,6 @@ const Expression_1 = require("./Expression");
 const Logger_1 = require("../Logger");
 const reflection_1 = require("../astUtils/reflection");
 const creators_1 = require("../astUtils/creators");
-const SymbolTable_1 = require("../SymbolTable");
 class Parser {
     constructor() {
         /**
@@ -21,7 +20,7 @@ class Parser {
         /**
          * The list of statements for the parsed file
          */
-        this.ast = new Statement_1.Body([]);
+        this.ast = new Statement_1.Body({ statements: [] });
         this.globalTerminators = [];
         /**
          * An array of CallExpression for the current function body
@@ -83,7 +82,7 @@ class Parser {
     }
     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 {
@@ -190,13 +189,15 @@ class Parser {
         return identifier;
     }
     enumMemberStatement() {
-        const statement = new Statement_1.EnumMemberStatement({});
-        statement.tokens.name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+        const name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+        let equalsToken;
+        let value;
         //look for `= SOME_EXPRESSION`
         if (this.check(TokenKind_1.TokenKind.Equal)) {
-            statement.tokens.equal = this.advance();
-            statement.value = this.expression();
+            equalsToken = this.advance();
+            value = this.expression();
         }
+        const statement = new Statement_1.EnumMemberStatement({ name: name, equals: equalsToken, value: value });
         return statement;
     }
     /**
@@ -209,20 +210,24 @@ class Parser {
         if (this.check(TokenKind_1.TokenKind.As)) {
             [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
         }
-        return new Statement_1.InterfaceFieldStatement(name, asToken, typeExpression, optionalKeyword);
+        return new Statement_1.InterfaceFieldStatement({ name: name, as: asToken, typeExpression: typeExpression, optional: optionalKeyword });
     }
-    consumeAsTokenAndTypeExpression() {
+    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()) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(asToken.text)), { range: asToken.range }));
+                if (!ignoreDiagnostics) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(asToken.text)), { range: asToken.range }));
+                }
                 //consume the statement separator
                 this.consumeStatementSeparators();
             }
             else if (this.peek().kind !== TokenKind_1.TokenKind.Identifier && !this.checkAny(...TokenKind_1.DeclarableTypes, ...TokenKind_1.AllowedTypeIdentifiers)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(asToken.text)), { range: asToken.range }));
+                if (!ignoreDiagnostics) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(asToken.text)), { range: asToken.range }));
+                }
             }
             else {
                 typeExpression = this.typeExpression();
@@ -254,7 +259,16 @@ class Parser {
         if (this.check(TokenKind_1.TokenKind.As)) {
             [asToken, returnTypeExpression] = this.consumeAsTokenAndTypeExpression();
         }
-        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeExpression, optionalKeyword);
+        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');
@@ -323,17 +337,24 @@ class Parser {
         }
         //consume the final `end interface` token
         const endInterfaceToken = this.consumeToken(TokenKind_1.TokenKind.EndInterface);
-        const statement = new Statement_1.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endInterfaceToken);
+        const statement = new Statement_1.InterfaceStatement({
+            interface: interfaceToken,
+            name: nameToken,
+            extends: extendsToken,
+            parentInterfaceName: parentInterfaceName,
+            body: body,
+            endInterface: endInterfaceToken
+        });
         this.exitAnnotationBlock(parentAnnotations);
         return statement;
     }
     enumDeclaration() {
-        const result = new Statement_1.EnumStatement({}, []);
+        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();
-        result.tokens.enum = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
-        result.tokens.name = this.tryIdentifier(...this.allowedLocalIdentifiers);
         this.consumeStatementSeparators();
+        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 {
@@ -352,7 +373,7 @@ class Parser {
                 }
                 if (decl) {
                     this.consumePendingAnnotations(decl);
-                    result.body.push(decl);
+                    body.push(decl);
                 }
                 else {
                     //we didn't find a declaration...flag tokens until next line
@@ -371,7 +392,13 @@ class Parser {
             }
         }
         //consume the final `end interface` token
-        result.tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
+        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;
     }
@@ -419,12 +446,15 @@ class Parser {
                 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);
                     //if we have an overrides keyword AND this method is called 'new', that's not allowed
-                    if (overrideKeyword && funcDeclaration.name.text.toLowerCase() === 'new') {
+                    if (overrideKeyword && funcDeclaration.tokens.name.text.toLowerCase() === 'new') {
                         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseOverrideKeywordOnConstructorFunction()), { range: overrideKeyword.range }));
                     }
-                    decl = new Statement_1.MethodStatement(accessModifier, funcDeclaration.name, funcDeclaration.func, overrideKeyword);
-                    //refer to this statement as parent of the expression
-                    funcDeclaration.func.functionStatement = decl;
+                    decl = new Statement_1.MethodStatement({
+                        modifiers: accessModifier,
+                        name: funcDeclaration.tokens.name,
+                        func: funcDeclaration.func,
+                        override: overrideKeyword
+                    });
                     //fields
                 }
                 else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
@@ -454,7 +484,14 @@ class Parser {
         if (endingKeyword.kind !== TokenKind_1.TokenKind.EndClass) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('class')), { range: endingKeyword.range }));
         }
-        const result = new Statement_1.ClassStatement(classKeyword, className, body, endingKeyword, extendsKeyword, parentClassName);
+        const result = new Statement_1.ClassStatement({
+            class: classKeyword,
+            name: className,
+            body: body,
+            endClass: endingKeyword,
+            extends: extendsKeyword,
+            parentClassName: parentClassName
+        });
         this.exitAnnotationBlock(parentAnnotations);
         return result;
     }
@@ -499,10 +536,17 @@ class Parser {
             equal = this.advance();
             initialValue = this.expression();
         }
-        return new Statement_1.FieldStatement(accessModifier, name, asToken, fieldTypeExpression, equal, initialValue, optionalKeyword);
+        return new Statement_1.FieldStatement({
+            accessModifier: accessModifier,
+            name: name,
+            as: asToken,
+            typeExpression: fieldTypeExpression,
+            equals: equal,
+            initialValue: initialValue,
+            optional: optionalKeyword
+        });
     }
     functionDeclaration(isAnonymous, checkIdentifier = true, onlyCallableAsMember = false) {
-        var _a;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
         try {
@@ -565,41 +609,43 @@ class Parser {
             }
             params.reduce((haveFoundOptional, param) => {
                 if (haveFoundOptional && !param.defaultValue) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.requiredParameterMayNotFollowOptionalParameter(param.name.text)), { range: param.range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.requiredParameterMayNotFollowOptionalParameter(param.tokens.name.text)), { range: param.range }));
                 }
                 return haveFoundOptional || !!param.defaultValue;
             }, false);
             this.consumeStatementSeparators(true);
-            let func = new Expression_1.FunctionExpression(params, undefined, //body
-            functionType, undefined, //ending keyword
-            leftParen, rightParen, asToken, typeExpression);
             //support ending the function with `end sub` OR `end function`
-            func.body = this.block();
+            let body = this.block();
             //if the parser was unable to produce a block, make an empty one so the AST makes some sense...
-            if (!func.body) {
-                func.body = new Statement_1.Block([], util_1.util.createRangeFromPositions(func.range.start, func.range.start));
-            }
-            func.body.symbolTable = new SymbolTable_1.SymbolTable(`Block: Function '${(_a = name === null || name === void 0 ? void 0 : name.text) !== null && _a !== void 0 ? _a : ''}'`, () => func.getSymbolTable());
-            if (!func.body) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callableBlockMissingEndKeyword(functionTypeText)), { range: this.peek().range }));
-                throw this.lastDiagnosticAsError();
-            }
             // consume 'end sub' or 'end function'
-            func.end = this.advance();
+            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: func.end.range }));
+            if (endFunctionType.kind !== expectedEndKind) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndCallableKeyword(functionTypeText, endFunctionType.text)), { range: endFunctionType.range }));
+            }
+            if (!body) {
+                body = new Statement_1.Block({
+                    statements: [],
+                    startingRange: util_1.util.createBoundingRange(functionType, name, leftParen, ...params, rightParen, asToken, typeExpression, endFunctionType)
+                });
             }
-            func.callExpressions = this.callExpressions;
+            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);
-                func.symbolTable.name += `: '${name === null || name === void 0 ? void 0 : name.text}'`;
-                func.functionStatement = result;
+                let result = new Statement_1.FunctionStatement({ name: name, func: func });
                 return result;
             }
         }
@@ -629,7 +675,13 @@ class Parser {
         if (this.check(TokenKind_1.TokenKind.As)) {
             [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
         }
-        return new Expression_1.FunctionParameterExpression(name, equalToken, defaultValue, asToken, typeExpression);
+        return new Expression_1.FunctionParameterExpression({
+            name: name,
+            equals: equalToken,
+            defaultValue: defaultValue,
+            as: asToken,
+            typeExpression: typeExpression
+        });
     }
     assignment() {
         let name = this.advance();
@@ -637,15 +689,32 @@ class Parser {
         if (TokenKind_1.DisallowedLocalIdentifiersText.has(name.text.toLowerCase())) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(name.text)), { range: name.range }));
         }
+        let asToken;
+        let typeExpression;
+        //look for `as SOME_TYPE`
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            this.warnIfNotBrighterScriptMode('typed assignment');
+            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+        }
         let operator = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOperatorAfterIdentifier(TokenKind_1.AssignmentOperators, name.text), ...TokenKind_1.AssignmentOperators);
         let value = this.expression();
         let result;
         if (operator.kind === TokenKind_1.TokenKind.Equal) {
-            result = new Statement_1.AssignmentStatement(operator, name, value);
+            result = new Statement_1.AssignmentStatement({ equals: operator, name: name, value: value, as: asToken, typeExpression: typeExpression });
         }
         else {
-            const nameExpression = new Expression_1.VariableExpression(name);
-            result = new Statement_1.AssignmentStatement(operator, name, new Expression_1.BinaryExpression(nameExpression, operator, value));
+            const nameExpression = new Expression_1.VariableExpression({ name: name });
+            result = new Statement_1.AssignmentStatement({
+                equals: operator,
+                name: name,
+                value: new Expression_1.BinaryExpression({
+                    left: nameExpression,
+                    operator: operator,
+                    right: value
+                }),
+                as: asToken,
+                typeExpression: typeExpression
+            });
         }
         return result;
     }
@@ -734,9 +803,31 @@ class Parser {
         // BrightScript is like python, in that variables can be declared without a `var`,
         // `let`, (...) keyword. As such, we must check the token *after* an identifier to figure
         // out what to do with it.
-        if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers) &&
-            this.checkAnyNext(...TokenKind_1.AssignmentOperators)) {
-            return this.assignment();
+        if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+            if (this.checkAnyNext(...TokenKind_1.AssignmentOperators)) {
+                return this.assignment();
+            }
+            else if (this.checkNext(TokenKind_1.TokenKind.As)) {
+                // may be a typed assignment
+                const backtrack = this.current;
+                let validTypeExpression = false;
+                try {
+                    // skip the identifier, and check for valid type expression
+                    this.advance();
+                    const parts = this.consumeAsTokenAndTypeExpression(true);
+                    validTypeExpression = !!((parts === null || parts === void 0 ? void 0 : parts[0]) && (parts === null || parts === void 0 ? void 0 : parts[1]));
+                }
+                catch (e) {
+                    // ignore any errors
+                }
+                finally {
+                    this.current = backtrack;
+                }
+                if (validTypeExpression) {
+                    // there is a valid 'as' and type expression
+                    return this.assignment();
+                }
+            }
         }
         //some BrighterScript keywords are allowed as a local identifiers, so we need to check for them AFTER the assignment check
         if (this.check(TokenKind_1.TokenKind.Interface)) {
@@ -769,7 +860,12 @@ class Parser {
         else {
             endWhile = this.advance();
         }
-        return new Statement_1.WhileStatement({ while: whileKeyword, endWhile: endWhile }, condition, whileBlock);
+        return new Statement_1.WhileStatement({
+            while: whileKeyword,
+            endWhile: endWhile,
+            condition: condition,
+            body: whileBlock
+        });
     }
     exitWhile() {
         let keyword = this.advance();
@@ -804,7 +900,16 @@ class Parser {
         }
         // WARNING: BrightScript doesn't delete the loop initial value after a for/to loop! It just
         // stays around in scope with whatever value it was when the loop exited.
-        return new Statement_1.ForStatement(forToken, initializer, toToken, finalValue, body, endForToken, stepToken, incrementExpression);
+        return new Statement_1.ForStatement({
+            for: forToken,
+            counterDeclaration: initializer,
+            to: toToken,
+            finalValue: finalValue,
+            body: body,
+            endFor: endForToken,
+            step: stepToken,
+            increment: incrementExpression
+        });
     }
     forEachStatement() {
         let forEach = this.advance();
@@ -832,8 +937,11 @@ class Parser {
         return new Statement_1.ForEachStatement({
             forEach: forEach,
             in: maybeIn,
-            endFor: endFor
-        }, name, target, body);
+            endFor: endFor,
+            item: name,
+            target: target,
+            body: body
+        });
     }
     exitFor() {
         let keyword = this.advance();
@@ -844,7 +952,7 @@ class Parser {
         //then this comment should be treated as a single-line comment
         let prev = this.previous();
         if ((prev === null || prev === void 0 ? void 0 : prev.range.end.line) === this.peek().range.start.line) {
-            return new Statement_1.CommentStatement([this.advance()]);
+            return new Statement_1.CommentStatement({ comments: [this.advance()] });
         }
         else {
             let comments = [this.advance()];
@@ -852,7 +960,7 @@ class Parser {
                 this.advance();
                 comments.push(this.advance());
             }
-            return new Statement_1.CommentStatement(comments);
+            return new Statement_1.CommentStatement({ comments: comments });
         }
     }
     namespaceStatement() {
@@ -861,7 +969,6 @@ class Parser {
         this.namespaceAndFunctionDepth++;
         let name = this.identifyingExpression();
         //set the current namespace name
-        let result = new Statement_1.NamespaceStatement(keyword, name, null, null);
         this.globalTerminators.push([TokenKind_1.TokenKind.EndNamespace]);
         let body = this.body();
         this.globalTerminators.pop();
@@ -874,8 +981,12 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('namespace')), { range: keyword.range }));
         }
         this.namespaceAndFunctionDepth--;
-        result.body = body;
-        result.endKeyword = endKeyword;
+        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.cacheRange();
         result.body.symbolTable.name += `: namespace '${result.name}'`;
@@ -891,7 +1002,7 @@ class Parser {
         if (firstIdentifier) {
             // force it into an identifier so the AST makes some sense
             firstIdentifier.kind = TokenKind_1.TokenKind.Identifier;
-            const varExpr = new Expression_1.VariableExpression(firstIdentifier);
+            const varExpr = new Expression_1.VariableExpression({ name: firstIdentifier });
             expr = varExpr;
             //consume multiple dot identifiers (i.e. `Name.Space.Can.Have.Many.Parts`)
             while (this.check(TokenKind_1.TokenKind.Dot)) {
@@ -905,7 +1016,7 @@ class Parser {
                 }
                 // force it into an identifier so the AST makes some sense
                 identifier.kind = TokenKind_1.TokenKind.Identifier;
-                expr = new Expression_1.DottedGetExpression(expr, identifier, dot);
+                expr = new Expression_1.DottedGetExpression({ obj: expr, name: identifier, dot: dot });
             }
         }
         return expr;
@@ -941,8 +1052,9 @@ class Parser {
         const statement = new Statement_1.ConstStatement({
             const: constToken,
             name: nameToken,
-            equals: equalToken
-        }, expression);
+            equals: equalToken,
+            value: expression
+        });
         return statement;
     }
     libraryStatement() {
@@ -955,9 +1067,11 @@ class Parser {
     }
     importStatement() {
         this.warnIfNotBrighterScriptMode('import statements');
-        let importStatement = new Statement_1.ImportStatement(this.advance(), 
-        //grab the next token only if it's a string
-        this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import'), TokenKind_1.TokenKind.StringLiteral));
+        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;
     }
     annotationExpression() {
@@ -966,7 +1080,7 @@ class Parser {
         if (identifier) {
             identifier.kind = TokenKind_1.TokenKind.Identifier;
         }
-        let annotation = new Expression_1.AnnotationExpression(atToken, identifier);
+        let annotation = new Expression_1.AnnotationExpression({ at: atToken, name: identifier });
         this.pendingAnnotations.push(annotation);
         //optional arguments
         if (this.check(TokenKind_1.TokenKind.LeftParen)) {
@@ -1004,13 +1118,23 @@ class Parser {
             alternate = this.expression();
         }
         catch (_b) { }
-        return new Expression_1.TernaryExpression(test, questionMarkToken, consequent, colonToken, alternate);
+        return new Expression_1.TernaryExpression({
+            test: test,
+            questionMark: questionMarkToken,
+            consequent: consequent,
+            colon: colonToken,
+            alternate: alternate
+        });
     }
     nullCoalescingExpression(test) {
         this.warnIfNotBrighterScriptMode('null coalescing operator');
         const questionQuestionToken = this.advance();
         const alternate = this.expression();
-        return new Expression_1.NullCoalescingExpression(test, questionQuestionToken, alternate);
+        return new Expression_1.NullCoalescingExpression({
+            consequent: test,
+            questionQuestion: questionQuestionToken,
+            alternate: alternate
+        });
     }
     regexLiteralExpression() {
         this.warnIfNotBrighterScriptMode('regular expression literal');
@@ -1036,16 +1160,16 @@ class Parser {
             let next = this.peek();
             if (next.kind === TokenKind_1.TokenKind.TemplateStringQuasi) {
                 //a quasi can actually be made up of multiple quasis when it includes char literals
-                currentQuasiExpressionParts.push(new Expression_1.LiteralExpression(next));
+                currentQuasiExpressionParts.push(new Expression_1.LiteralExpression({ value: next }));
                 this.advance();
             }
             else if (next.kind === TokenKind_1.TokenKind.EscapedCharCodeLiteral) {
-                currentQuasiExpressionParts.push(new Expression_1.EscapedCharCodeLiteralExpression(next));
+                currentQuasiExpressionParts.push(new Expression_1.EscapedCharCodeLiteralExpression({ value: next }));
                 this.advance();
             }
             else {
                 //finish up the current quasi
-                quasis.push(new Expression_1.TemplateStringQuasiExpression(currentQuasiExpressionParts));
+                quasis.push(new Expression_1.TemplateStringQuasiExpression({ expressions: currentQuasiExpressionParts }));
                 currentQuasiExpressionParts = [];
                 if (next.kind === TokenKind_1.TokenKind.TemplateStringExpressionBegin) {
                     this.advance();
@@ -1063,7 +1187,7 @@ class Parser {
             }
         }
         //store the final set of quasis
-        quasis.push(new Expression_1.TemplateStringQuasiExpression(currentQuasiExpressionParts));
+        quasis.push(new Expression_1.TemplateStringQuasiExpression({ expressions: currentQuasiExpressionParts }));
         if (this.isAtEnd()) {
             //error - missing backtick
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unterminatedTemplateStringAtEndOfFile()), { range: util_1.util.getRange(openingBacktick, this.peek()) }));
@@ -1072,45 +1196,63 @@ class Parser {
         else {
             let closingBacktick = this.advance();
             if (isTagged) {
-                return new Expression_1.TaggedTemplateStringExpression(tagName, openingBacktick, quasis, expressions, closingBacktick);
+                return new Expression_1.TaggedTemplateStringExpression({
+                    tagName: tagName,
+                    openingBacktick: openingBacktick,
+                    quasis: quasis,
+                    expressions: expressions,
+                    closingBacktick: closingBacktick
+                });
             }
             else {
-                return new Expression_1.TemplateStringExpression(openingBacktick, quasis, expressions, closingBacktick);
+                return new Expression_1.TemplateStringExpression({
+                    openingBacktick: openingBacktick,
+                    quasis: quasis,
+                    expressions: expressions,
+                    closingBacktick: closingBacktick
+                });
             }
         }
     }
     tryCatchStatement() {
         const tryToken = this.advance();
-        const statement = new Statement_1.TryCatchStatement({ try: tryToken });
+        let endTryToken;
+        let catchStmt;
         //ensure statement separator
         this.consumeStatementSeparators();
-        statement.tryBranch = this.block(TokenKind_1.TokenKind.Catch, TokenKind_1.TokenKind.EndTry);
+        let tryBranch = this.block(TokenKind_1.TokenKind.Catch, TokenKind_1.TokenKind.EndTry);
         const peek = this.peek();
         if (peek.kind !== TokenKind_1.TokenKind.Catch) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedCatchBlockInTryCatch()), { range: this.peek().range }));
-            //gracefully handle end-try
-            if (peek.kind === TokenKind_1.TokenKind.EndTry) {
-                statement.tokens.endTry = this.advance();
-            }
-            return statement;
         }
-        const catchStmt = new Statement_1.CatchStatement({ catch: this.advance() });
-        statement.catchStatement = catchStmt;
-        const exceptionVarToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingExceptionVarToFollowCatch(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
-        if (exceptionVarToken) {
-            // force it into an identifier so the AST makes some sense
-            exceptionVarToken.kind = TokenKind_1.TokenKind.Identifier;
-            catchStmt.exceptionVariable = exceptionVarToken;
+        else {
+            const catchToken = this.advance();
+            const exceptionVarToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingExceptionVarToFollowCatch(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+            if (exceptionVarToken) {
+                // force it into an identifier so the AST makes some sense
+                exceptionVarToken.kind = TokenKind_1.TokenKind.Identifier;
+            }
+            //ensure statement sepatator
+            this.consumeStatementSeparators();
+            const catchBranch = this.block(TokenKind_1.TokenKind.EndTry);
+            catchStmt = new Statement_1.CatchStatement({
+                catch: catchToken,
+                exceptionVariable: exceptionVarToken,
+                catchBranch: catchBranch
+            });
         }
-        //ensure statement sepatator
-        this.consumeStatementSeparators();
-        catchStmt.catchBranch = this.block(TokenKind_1.TokenKind.EndTry);
         if (this.peek().kind !== TokenKind_1.TokenKind.EndTry) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndTryToTerminateTryCatch()), { range: this.peek().range }));
         }
         else {
-            statement.tokens.endTry = this.advance();
+            endTryToken = this.advance();
         }
+        const statement = new Statement_1.TryCatchStatement({
+            try: tryToken,
+            tryBranch: tryBranch,
+            catchStatement: catchStmt,
+            endTry: endTryToken
+        });
         return statement;
     }
     throwStatement() {
@@ -1122,7 +1264,7 @@ class Parser {
         else {
             expression = this.expression();
         }
-        return new Statement_1.ThrowStatement(throwToken, expression);
+        return new Statement_1.ThrowStatement({ throw: throwToken, expression: expression });
     }
     dimStatement() {
         const dim = this.advance();
@@ -1153,7 +1295,13 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExpressionsInDimStatement()), { range: this.peek().range }));
         }
         let rightSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingRightSquareBracketAfterDimIdentifier(), TokenKind_1.TokenKind.RightSquareBracket);
-        return new Statement_1.DimStatement(dim, identifier, leftSquareBracket, expressions, rightSquareBracket);
+        return new Statement_1.DimStatement({
+            dim: dim,
+            name: identifier,
+            openingSquare: leftSquareBracket,
+            dimensions: expressions,
+            closingSquare: rightSquareBracket
+        });
     }
     ifStatement() {
         // colon before `if` is usually not allowed, unless it's after `then`
@@ -1263,8 +1411,12 @@ class Parser {
             if: ifToken,
             then: thenToken,
             endIf: endIfToken,
-            else: elseToken
-        }, condition, thenBranch, elseBranch, isInlineIfThen);
+            else: elseToken,
+            condition: condition,
+            thenBranch: thenBranch,
+            elseBranch: elseBranch,
+            isInline: isInlineIfThen
+        });
     }
     //consume a `then` or `else` branch block of an `if` statement
     blockConditionalBranch(ifToken) {
@@ -1335,7 +1487,7 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(colon.text)), { range: colon.range }));
             }
         }
-        return new Statement_1.Block(statements, startingRange);
+        return new Statement_1.Block({ statements: statements, startingRange: startingRange });
     }
     expressionStatement(expr) {
         let expressionStart = this.peek();
@@ -1349,15 +1501,15 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.incrementDecrementOperatorsAreNotAllowedAsResultOfFunctionCall()), { range: expressionStart.range }));
                 throw this.lastDiagnosticAsError();
             }
-            const result = new Statement_1.IncrementStatement(expr, operator);
+            const result = new Statement_1.IncrementStatement({ value: expr, operator: operator });
             return result;
         }
         if ((0, reflection_1.isCallExpression)(expr) || (0, reflection_1.isCallfuncExpression)(expr)) {
-            return new Statement_1.ExpressionStatement(expr);
+            return new Statement_1.ExpressionStatement({ expression: expr });
         }
         //at this point, it's probably an error. However, we recover a little more gracefully by creating an inclosing ExpressionStatement
         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression()), { range: expressionStart.range }));
-        return new Statement_1.ExpressionStatement(expr);
+        return new Statement_1.ExpressionStatement({ expression: expr });
     }
     setStatement() {
         /**
@@ -1373,14 +1525,25 @@ class Parser {
             let right = this.expression();
             // Create a dotted or indexed "set" based on the left-hand side's type
             if ((0, reflection_1.isIndexedGetExpression)(left)) {
-                return new Statement_1.IndexedSetStatement(left.obj, left.index, operator.kind === TokenKind_1.TokenKind.Equal
-                    ? right
-                    : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare);
+                return new Statement_1.IndexedSetStatement({
+                    obj: left.obj,
+                    indexes: left.indexes,
+                    value: operator.kind === TokenKind_1.TokenKind.Equal
+                        ? right
+                        : new Expression_1.BinaryExpression({ left: left, operator: operator, right: right }),
+                    openingSquare: left.tokens.openingSquare,
+                    closingSquare: left.tokens.closingSquare
+                });
             }
             else if ((0, reflection_1.isDottedGetExpression)(left)) {
-                return new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === TokenKind_1.TokenKind.Equal
-                    ? right
-                    : new Expression_1.BinaryExpression(left, operator, right), left.dot);
+                return new Statement_1.DottedSetStatement({
+                    obj: left.obj,
+                    name: left.tokens.name,
+                    value: operator.kind === TokenKind_1.TokenKind.Equal
+                        ? right
+                        : new Expression_1.BinaryExpression({ left: left, operator: operator, right: right }),
+                    dot: left.tokens.dot
+                });
             }
         }
         return this.expressionStatement(expr);
@@ -1413,27 +1576,27 @@ class Parser {
         if ((0, Token_1.isToken)(last)) {
             // TODO: error, expected value
         }
-        return new Statement_1.PrintStatement({ print: printKeyword }, values);
+        return new Statement_1.PrintStatement({ print: printKeyword, expressions: values });
     }
     /**
      * Parses a return statement with an optional return value.
      * @returns an AST representation of a return statement.
      */
     returnStatement() {
-        let tokens = { return: this.previous() };
+        let options = { return: this.previous() };
         if (this.checkEndOfStatement()) {
-            return new Statement_1.ReturnStatement(tokens);
+            return new Statement_1.ReturnStatement(options);
         }
         let toReturn = this.check(TokenKind_1.TokenKind.Else) ? undefined : this.expression();
-        return new Statement_1.ReturnStatement(tokens, toReturn);
+        return new Statement_1.ReturnStatement(Object.assign(Object.assign({}, options), { value: toReturn }));
     }
     /**
      * Parses a `label` statement
      * @returns an AST representation of an `label` statement.
      */
     labelStatement() {
-        let tokens = {
-            identifier: this.advance(),
+        let options = {
+            name: this.advance(),
             colon: this.advance()
         };
         //label must be alone on its line, this is probably not a label
@@ -1442,7 +1605,7 @@ class Parser {
             this.current -= 2;
             throw new CancelStatementError();
         }
-        return new Statement_1.LabelStatement(tokens);
+        return new Statement_1.LabelStatement(options);
     }
     /**
      * Parses a `continue` statement
@@ -1469,16 +1632,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.
@@ -1530,7 +1693,7 @@ class Parser {
             }
         }
         this.exitAnnotationBlock(parentAnnotations);
-        return new Statement_1.Block(statements, startingToken.range);
+        return new Statement_1.Block({ statements: statements, startingRange: startingToken.range });
     }
     /**
      * Attach pending annotations to the provided statement,
@@ -1569,7 +1732,7 @@ class Parser {
                     // myVal = foo() as dynamic as string
                     [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
                     if (asToken && typeExpression) {
-                        expression = new Expression_1.TypeCastExpression(expression, asToken, typeExpression);
+                        expression = new Expression_1.TypeCastExpression({ obj: expression, as: asToken, typeExpression: typeExpression });
                     }
                 }
                 else {
@@ -1606,7 +1769,7 @@ class Parser {
         while (this.matchAny(TokenKind_1.TokenKind.And, TokenKind_1.TokenKind.Or)) {
             let operator = this.previous();
             let right = this.relational();
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
@@ -1615,7 +1778,7 @@ class Parser {
         while (this.matchAny(TokenKind_1.TokenKind.Equal, TokenKind_1.TokenKind.LessGreater, TokenKind_1.TokenKind.Greater, TokenKind_1.TokenKind.GreaterEqual, TokenKind_1.TokenKind.Less, TokenKind_1.TokenKind.LessEqual)) {
             let operator = this.previous();
             let right = this.additive();
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
@@ -1625,7 +1788,7 @@ class Parser {
         while (this.matchAny(TokenKind_1.TokenKind.Plus, TokenKind_1.TokenKind.Minus)) {
             let operator = this.previous();
             let right = this.multiplicative();
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
@@ -1634,7 +1797,7 @@ class Parser {
         while (this.matchAny(TokenKind_1.TokenKind.Forwardslash, TokenKind_1.TokenKind.Backslash, TokenKind_1.TokenKind.Star, TokenKind_1.TokenKind.Mod, TokenKind_1.TokenKind.LeftShift, TokenKind_1.TokenKind.RightShift)) {
             let operator = this.previous();
             let right = this.exponential();
-            expr = new Expression_1.BinaryExpression(expr, operator, right);
+            expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
         return expr;
     }
@@ -1643,7 +1806,7 @@ class Parser {
         while (this.match(TokenKind_1.TokenKind.Caret)) {
             let operator = this.previous();
             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;
     }
@@ -1653,7 +1816,7 @@ class Parser {
             this.current++; //advance
             let operator = this.previous();
             let right = this.relational();
-            return new Expression_1.UnaryExpression(operator, right);
+            return new Expression_1.UnaryExpression({ operator: operator, right: right });
         }
         else if (nextKind === TokenKind_1.TokenKind.Minus || nextKind === TokenKind_1.TokenKind.Plus) {
             this.current++; //advance
@@ -1661,25 +1824,38 @@ class Parser {
             let right = nextKind === TokenKind_1.TokenKind.Not
                 ? this.boolean()
                 : this.prefixUnary();
-            return new Expression_1.UnaryExpression(operator, right);
+            return new Expression_1.UnaryExpression({ operator: operator, right: right });
         }
         return this.call();
     }
     indexedGet(expr) {
         let openingSquare = this.previous();
         let questionDotToken = this.getMatchingTokenAtOffset(-2, TokenKind_1.TokenKind.QuestionDot);
-        let index;
-        let closingSquare;
+        let indexes = [];
+        //consume leading newlines
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
         try {
-            index = this.expression();
+            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)) { }
-        closingSquare = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedRightSquareBraceAfterArrayOrObjectIndex(), TokenKind_1.TokenKind.RightSquareBracket);
-        return new Expression_1.IndexedGetExpression(expr, index, openingSquare, closingSquare, questionDotToken);
+        const closingSquare = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedRightSquareBraceAfterArrayOrObjectIndex(), TokenKind_1.TokenKind.RightSquareBracket);
+        return new Expression_1.IndexedGetExpression({
+            obj: expr,
+            indexes: indexes,
+            openingSquare: openingSquare,
+            closingSquare: closingSquare,
+            questionDot: questionDotToken
+        });
     }
     newExpression() {
         var _a;
@@ -1692,12 +1868,12 @@ class Parser {
             // wrap the name in an expression
             const endOfStatementRange = util_1.util.createRangeFromPositions(newToken.range.end, (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.range.end);
             const exprStmt = nameExpr !== null && nameExpr !== void 0 ? nameExpr : (0, creators_1.createStringLiteral)('', endOfStatementRange);
-            return new Statement_1.ExpressionStatement(exprStmt);
+            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);
+        let result = new Expression_1.NewExpression({ new: newToken, call: call });
         return result;
     }
     /**
@@ -1711,7 +1887,14 @@ class Parser {
         methodName.kind = TokenKind_1.TokenKind.Identifier;
         let openParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOpenParenToFollowCallfuncIdentifier(), TokenKind_1.TokenKind.LeftParen);
         let call = this.finishCall(openParen, callee, false);
-        return new Expression_1.CallfuncExpression(callee, operator, methodName, openParen, call.args, call.closingParen);
+        return new Expression_1.CallfuncExpression({
+            callee: callee,
+            operator: operator,
+            methodName: methodName,
+            openingParen: openParen,
+            args: call.args,
+            closingParen: call.tokens.closingParen
+        });
     }
     call() {
         if (this.check(TokenKind_1.TokenKind.New) && this.checkAnyNext(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
@@ -1740,7 +1923,7 @@ class Parser {
                     }
                     // force it into an identifier so the AST makes some sense
                     name.kind = TokenKind_1.TokenKind.Identifier;
-                    expr = new Expression_1.DottedGetExpression(expr, name, dot);
+                    expr = new Expression_1.DottedGetExpression({ obj: expr, name: name, dot: dot });
                 }
             }
             else if (this.checkAny(TokenKind_1.TokenKind.At, TokenKind_1.TokenKind.QuestionAt)) {
@@ -1751,7 +1934,7 @@ class Parser {
                 if (!name) {
                     break;
                 }
-                expr = new Expression_1.XmlAttributeGetExpression(expr, name, dot);
+                expr = new Expression_1.XmlAttributeGetExpression({ obj: expr, name: name, at: dot });
                 //only allow a single `@` expression
                 break;
             }
@@ -1783,7 +1966,12 @@ class Parser {
         }
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
         const closingParen = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), TokenKind_1.TokenKind.RightParen);
-        let expression = new Expression_1.CallExpression(callee, openingParen, closingParen, args);
+        let expression = new Expression_1.CallExpression({
+            callee: callee,
+            openingParen: openingParen,
+            args: args,
+            closingParen: closingParen
+        });
         if (addToCallExpressionList) {
             this.callExpressions.push(expression);
         }
@@ -1802,14 +1990,14 @@ class Parser {
                 let operator = this.previous();
                 let right = this.getTypeExpressionPart(changedTokens);
                 if (right) {
-                    expr = new Expression_1.BinaryExpression(expr, operator, right);
+                    expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
                 }
                 else {
                     break;
                 }
             }
             if (expr) {
-                return new Expression_1.TypeExpression(expr);
+                return new Expression_1.TypeExpression({ expression: expr });
             }
         }
         catch (error) {
@@ -1831,7 +2019,7 @@ class Parser {
         let expr;
         if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
             // if this is just a type, just use directly
-            expr = new Expression_1.VariableExpression(this.advance());
+            expr = new Expression_1.VariableExpression({ name: this.advance() });
         }
         else {
             if (this.checkAny(...TokenKind_1.AllowedTypeIdentifiers)) {
@@ -1856,7 +2044,7 @@ class Parser {
                 const leftBracket = this.advance();
                 if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
                     const rightBracket = this.advance();
-                    expr = new Expression_1.TypedArrayExpression(expr, leftBracket, rightBracket);
+                    expr = new Expression_1.TypedArrayExpression({ innerType: expr, leftBracket: leftBracket, rightBracket: rightBracket });
                 }
             }
         }
@@ -1865,10 +2053,10 @@ class Parser {
     primary() {
         switch (true) {
             case this.matchAny(TokenKind_1.TokenKind.False, TokenKind_1.TokenKind.True, TokenKind_1.TokenKind.Invalid, TokenKind_1.TokenKind.IntegerLiteral, TokenKind_1.TokenKind.LongIntegerLiteral, TokenKind_1.TokenKind.FloatLiteral, TokenKind_1.TokenKind.DoubleLiteral, TokenKind_1.TokenKind.StringLiteral):
-                return new Expression_1.LiteralExpression(this.previous());
+                return new Expression_1.LiteralExpression({ value: this.previous() });
             //capture source literals (LINE_NUM if brightscript, or a bunch of them if brighterscript)
             case this.matchAny(TokenKind_1.TokenKind.LineNumLiteral, ...(this.options.mode === ParseMode.BrightScript ? [] : TokenKind_1.BrighterScriptSourceLiterals)):
-                return new Expression_1.SourceLiteralExpression(this.previous());
+                return new Expression_1.SourceLiteralExpression({ value: this.previous() });
             //template string
             case this.check(TokenKind_1.TokenKind.BackTick):
                 return this.templateString(false);
@@ -1876,12 +2064,12 @@ class Parser {
             case this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedLocalIdentifiers) && this.checkNext(TokenKind_1.TokenKind.BackTick):
                 return this.templateString(true);
             case this.matchAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers):
-                return new Expression_1.VariableExpression(this.previous());
+                return new Expression_1.VariableExpression({ name: this.previous() });
             case this.match(TokenKind_1.TokenKind.LeftParen):
                 let left = this.previous();
                 let expr = this.expression();
                 let right = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftParenAfterExpression(), TokenKind_1.TokenKind.RightParen);
-                return new Expression_1.GroupingExpression({ left: left, right: right }, expr);
+                return new Expression_1.GroupingExpression({ leftParen: left, rightParen: right, expression: expr });
             case this.matchAny(TokenKind_1.TokenKind.LeftSquareBracket):
                 return this.arrayLiteral();
             case this.match(TokenKind_1.TokenKind.LeftCurlyBrace):
@@ -1890,13 +2078,13 @@ class Parser {
                 let token = Object.assign(this.previous(), {
                     kind: TokenKind_1.TokenKind.Identifier
                 });
-                return new Expression_1.VariableExpression(token);
+                return new Expression_1.VariableExpression({ name: token });
             case this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub):
                 return this.anonymousFunction();
             case this.check(TokenKind_1.TokenKind.RegexLiteral):
                 return this.regexLiteralExpression();
             case this.check(TokenKind_1.TokenKind.Comment):
-                return new Statement_1.CommentStatement([this.advance()]);
+                return new Statement_1.CommentStatement({ comments: [this.advance()] });
             default:
                 //if we found an expected terminator, don't throw a diagnostic...just return undefined
                 if (this.checkAny(...this.peekGlobalTerminators())) {
@@ -1914,7 +2102,7 @@ class Parser {
         let openingSquare = this.previous();
         //add any comment found right after the opening square
         if (this.check(TokenKind_1.TokenKind.Comment)) {
-            elements.push(new Statement_1.CommentStatement([this.advance()]));
+            elements.push(new Statement_1.CommentStatement({ comments: [this.advance()] }));
         }
         while (this.match(TokenKind_1.TokenKind.Newline)) {
         }
@@ -1925,7 +2113,7 @@ class Parser {
                 while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
                     if (this.checkPrevious(TokenKind_1.TokenKind.Comment) || this.check(TokenKind_1.TokenKind.Comment)) {
                         let comment = this.check(TokenKind_1.TokenKind.Comment) ? this.advance() : this.previous();
-                        elements.push(new Statement_1.CommentStatement([comment]));
+                        elements.push(new Statement_1.CommentStatement({ comments: [comment] }));
                     }
                     while (this.match(TokenKind_1.TokenKind.Newline)) {
                     }
@@ -1944,7 +2132,7 @@ class Parser {
             closingSquare = this.previous();
         }
         //this.consume("Expected newline or ':' after array literal", TokenKind.Newline, TokenKind.Colon, TokenKind.Eof);
-        return new Expression_1.ArrayLiteralExpression(elements, openingSquare, closingSquare);
+        return new Expression_1.ArrayLiteralExpression({ elements: elements, open: openingSquare, close: closingSquare });
     }
     aaLiteral() {
         let openingBrace = this.previous();
@@ -1976,23 +2164,27 @@ class Parser {
             try {
                 if (this.check(TokenKind_1.TokenKind.Comment)) {
                     lastAAMember = null;
-                    members.push(new Statement_1.CommentStatement([this.advance()]));
+                    members.push(new Statement_1.CommentStatement({ comments: [this.advance()] }));
                 }
                 else {
                     let k = key();
                     let expr = this.expression();
-                    lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr);
+                    lastAAMember = new Expression_1.AAMemberExpression({
+                        key: k.keyToken,
+                        colon: k.colonToken,
+                        value: expr
+                    });
                     members.push(lastAAMember);
                 }
                 while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
                     // collect comma at end of expression
                     if (lastAAMember && this.checkPrevious(TokenKind_1.TokenKind.Comma)) {
-                        lastAAMember.commaToken = this.previous();
+                        lastAAMember.tokens.comma = this.previous();
                     }
                     //check for comment at the end of the current line
                     if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
                         let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
-                        members.push(new Statement_1.CommentStatement([token]));
+                        members.push(new Statement_1.CommentStatement({ comments: [token] }));
                     }
                     else {
                         this.consumeStatementSeparators(true);
@@ -2000,7 +2192,7 @@ class Parser {
                         if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
                             let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
                             lastAAMember = null;
-                            members.push(new Statement_1.CommentStatement([token]));
+                            members.push(new Statement_1.CommentStatement({ comments: [token] }));
                             continue;
                         }
                         if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
@@ -2008,7 +2200,11 @@ class Parser {
                         }
                         let k = key();
                         let expr = this.expression();
-                        lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr);
+                        lastAAMember = new Expression_1.AAMemberExpression({
+                            key: k.keyToken,
+                            colon: k.colonToken,
+                            value: expr
+                        });
                         members.push(lastAAMember);
                     }
                 }
@@ -2021,7 +2217,7 @@ class Parser {
         else {
             closingBrace = this.previous();
         }
-        const aaExpr = new Expression_1.AALiteralExpression(members, openingBrace, closingBrace);
+        const aaExpr = new Expression_1.AALiteralExpression({ elements: members, open: openingBrace, close: closingBrace });
         return aaExpr;
     }
     /**
@@ -2130,6 +2326,11 @@ class Parser {
         var _a;
         return ((_a = this.previous()) === null || _a === void 0 ? void 0 : _a.kind) === tokenKind;
     }
+    /**
+     * Check that the next token kind is the expected kind
+     * @param tokenKind the expected next kind
+     * @returns true if the next tokenKind is the expected value
+     */
     check(tokenKind) {
         const nextKind = this.peek().kind;
         if (nextKind === TokenKind_1.TokenKind.Eof) {